简介：TYPE-A转TYPE-A可编程电流表，可设置20mA-3A可编程电流，支持5-35V供电，做为快充中间件也不在话下，小幅度波动容忍度可调，大电流极速响应，极速断开。

好的，作为一名高级嵌入式软件开发工程师，我将为您详细解析并实现一个TYPE-A转TYPE-A可编程电流表嵌入式系统的软件架构和代码。这个项目旨在展示一个从需求分析到最终实现的完整嵌入式系统开发流程，确保系统可靠、高效、可扩展。
关注微信公众号，提前获取相关推文

项目概述

本项目是一个TYPE-A转TYPE-A可编程电流表，核心功能是允许用户设置并输出20mA至3A范围内的可编程电流。它支持5-35V的宽电压输入，并可以作为快充协议的中间件使用。为了应对实际应用中的复杂场景，系统需要具备以下关键特性：

• 精确可编程电流输出: 能够在20mA-3A范围内精确设置电流值，并保持稳定输出。
• 宽电压输入范围: 支持5-35V输入电压，适应不同的电源环境。
• 快速响应: 对电流设置变化快速响应，并能迅速调整输出。
• 过流保护与快速断开: 当检测到异常大电流时，能迅速断开输出，保护设备和负载。
• 小幅度波动容忍度: 能够容忍一定范围内的电流波动，避免误触发保护机制。
• 用户友好的界面: 通过显示屏和按键提供直观的用户操作界面。
• 可扩展性: 软件架构应易于扩展，方便未来添加新功能，例如更高级的快充协议支持、数据记录等。

系统架构设计

为了实现上述功能和特性，我们采用分层架构来设计嵌入式软件系统。分层架构能够提高代码的模块化程度、可维护性和可扩展性。本系统采用四层架构：硬件抽象层 (HAL), 驱动层 (Driver), 服务层 (Service), 和 **应用层 (Application)**。

+---------------------+  应用层 (Application)
|  用户界面模块       |
|  电流设置模块       |
|  显示管理模块       |
|  错误处理模块       |
+---------------------+
         |
+---------------------+  服务层 (Service)
|  电流控制服务       |
|  电压/电流测量服务  |
|  按键输入服务       |
|  显示驱动服务       |
|  保护机制服务       |
+---------------------+
         |
+---------------------+  驱动层 (Driver)
|  ADC 驱动           |
|  DAC 驱动           |
|  GPIO 驱动          |
|  定时器驱动         |
|  显示屏驱动         |
+---------------------+
         |
+---------------------+  硬件抽象层 (HAL)
|  平台相关的硬件接口  |  (例如：寄存器定义，底层驱动函数)
+---------------------+
         |
     硬件平台 (MCU, ADC, DAC, Display, Buttons)

各层功能详细说明：

1. 硬件抽象层 (HAL - Hardware Abstraction Layer):

   • 目的: 隔离硬件平台的差异性，为上层驱动层提供统一的硬件访问接口。
   • 功能: 定义与具体硬件平台相关的底层操作，例如：
     • 寄存器定义: 定义 MCU 及外设的寄存器地址和位域。
     • 底层驱动函数: 提供直接操作硬件寄存器的函数，例如：HAL_GPIO_SetPinOutput(), HAL_ADC_StartConversion(), HAL_DAC_SetValue()。
     • 时钟配置: 初始化和配置系统时钟、外设时钟。
     • 中断管理: 配置和管理中断向量表，处理中断请求。
   • 优点: 提高代码的可移植性。当更换硬件平台时，只需要修改 HAL 层代码，上层代码无需改动。

2. 驱动层 (Driver Layer):

   • 目的: 封装硬件操作细节，为服务层提供易于使用的硬件驱动接口。
   • 功能: 基于 HAL 层提供的接口，实现各种硬件设备的驱动程序，例如：
     • ADC 驱动: 初始化 ADC 模块，配置采样通道、采样率、分辨率等参数，提供读取 ADC 值的函数，例如：ADC_Init(), ADC_ReadChannel().
     • DAC 驱动: 初始化 DAC 模块，配置输出通道、输出模式等参数，提供设置 DAC 输出值的函数，例如：DAC_Init(), DAC_SetValue().
     • GPIO 驱动: 初始化 GPIO 引脚，配置引脚为输入或输出模式，提供设置和读取 GPIO 引脚状态的函数，例如：GPIO_Init(), GPIO_SetOutput(), GPIO_ReadInput().
     • 定时器驱动: 初始化定时器模块，配置定时器的工作模式、预分频器、计数器等参数，提供启动、停止定时器以及获取定时器计数值的函数，例如：Timer_Init(), Timer_Start(), Timer_GetCounter(). (用于PWM控制电流或定时采样)
     • 显示屏驱动: 初始化显示屏，配置显示屏的接口类型（例如 SPI, I2C），提供在显示屏上显示字符、数字、图形等功能的函数，例如：Display_Init(), Display_WriteString(), Display_DrawPixel().
   • 优点: 将硬件操作细节隐藏在驱动程序内部，服务层只需调用驱动层提供的接口，无需关心底层的硬件操作。

3. 服务层 (Service Layer):

   • 目的: 提供高层次的、与业务逻辑相关的服务接口，供应用层调用。
   • 功能: 基于驱动层提供的硬件驱动，实现各种系统服务，例如：
     • 电流控制服务: 实现电流的精确控制，包括设置目标电流值、PID 控制算法 (或其他控制算法) 的实现、电流反馈的读取和处理等。例如：CurrentControl_Init(), CurrentControl_SetCurrent(mA), CurrentControl_EnableOutput(), CurrentControl_DisableOutput().
     • 电压/电流测量服务: 使用 ADC 驱动读取电压和电流值，并进行必要的滤波和校准处理，提供获取电压和电流值的接口。例如：Measurement_Init(), Measurement_GetVoltage(), Measurement_GetCurrent().
     • 按键输入服务: 检测按键状态，处理按键事件（例如单击、长按），提供按键事件回调函数或消息队列。例如：Button_Init(), Button_RegisterCallback(), Button_GetEvent().
     • 显示驱动服务: 封装显示屏驱动，提供更高级的显示功能，例如显示数字、字符串、图标、菜单等。例如：DisplayService_Init(), DisplayService_ShowValue(value, unit), DisplayService_ShowMenu().
     • 保护机制服务: 实现过流保护、过压保护、短路保护等机制，监控电压和电流值，当检测到异常情况时，触发保护动作（例如断开输出、报警）。例如：Protection_Init(), Protection_EnableOverCurrentProtection(), Protection_SetOverCurrentThreshold(mA).
   • 优点: 将业务逻辑相关的操作封装在服务层，应用层只需调用服务层提供的接口，专注于用户界面和应用逻辑的实现。

4. 应用层 (Application Layer):

   • 目的: 实现用户界面的交互逻辑和应用功能。
   • 功能: 基于服务层提供的服务接口，实现用户可见的应用功能，例如：
     • 用户界面模块: 处理用户输入（按键操作），显示系统状态和设置，提供友好的用户交互界面。
     • 电流设置模块: 接收用户通过按键输入的电流设置值，调用电流控制服务设置目标电流。
     • 显示管理模块: 负责更新显示屏的内容，显示电压、电流、设置值、状态信息等。
     • 错误处理模块: 处理系统运行过程中发生的错误，例如传感器故障、保护机制触发等，并在显示屏上显示错误信息，必要时采取安全措施。
   • 优点: 专注于应用功能的实现，与底层硬件和服务解耦，提高开发效率和代码可维护性。

关键技术和方法

在本项目中，我们将采用以下关键技术和方法，这些技术和方法都经过了实践验证，能够保证系统的可靠性、高效性和可扩展性：

1. 精确电流控制: 采用DAC (数模转换器) 输出控制电压，结合运放和功率器件构建恒流源电路。为了提高电流输出的精度和稳定性，将采用闭环反馈控制，使用 ADC (模数转换器) 采样输出电流，通过 PID (比例-积分-微分) 控制算法 动态调整 DAC 输出值，实现精确的电流控制。

2. 电流采样和电压采样: 使用高精度 ADC 模块进行电流和电压采样。电流采样通常采用高精度采样电阻 (shunt resistor)，将电流转换为电压信号进行采样。为了提高采样精度，可以采用差分 ADC 输入 和 过采样技术。

3. 快速响应和过流保护: 为了实现快速响应，PID 控制算法需要进行参数优化，并采用快速 ADC 采样和 DAC 输出。过流保护机制通过实时监测输出电流，当电流超过预设阈值时，立即关闭 DAC 输出或控制功率器件，实现快速断开。

4. 小幅度波动容忍度: 在软件层面实现数字滤波算法，例如移动平均滤波或卡尔曼滤波，对 ADC 采样值进行滤波处理，滤除高频噪声和小幅度波动。同时，在保护机制中，可以设置延时触发或多重采样确认，避免因瞬时波动导致的误触发。

5. 用户界面设计: 采用小尺寸 LCD 或 OLED 显示屏，结合按键输入，设计简洁直观的用户操作界面。显示内容包括：目标电流值、实际输出电流值、输入电压值、系统状态、错误信息等。

6. 模块化编程和分层架构: 采用分层架构和模块化编程方法，将系统划分为不同的模块和层次，提高代码的可读性、可维护性和可扩展性。每个模块负责特定的功能，模块之间通过清晰的接口进行通信。

7. 代码规范和版本控制: 严格遵守代码规范，例如 MISRA-C 或 AUTOSAR C++14 (如果使用 C++)，提高代码质量和可维护性。使用 Git 等版本控制工具进行代码管理，方便代码的版本管理、协作开发和 bug 追踪。

8. 单元测试和集成测试: 在开发过程中进行充分的单元测试和集成测试，确保每个模块的功能正确性和系统整体的稳定性。使用测试驱动开发 (TDD) 方法，先编写测试用例，再编写代码，提高代码质量。

C 代码实现 (示例代码框架，并非完整 3000 行，完整代码需根据具体硬件平台和功能细节扩充)

为了演示代码架构和关键模块的实现，以下提供 C 代码的框架和部分核心模块的示例代码。请注意，这只是代码框架，实际项目需要根据具体的硬件平台 (例如 MCU 型号、ADC/DAC 芯片型号、显示屏型号等) 和功能细节进行详细的开发和完善。为了达到 3000 行代码的要求，需要填充各个模块的具体实现，包括详细的初始化配置、错误处理、更完善的 PID 控制算法、更丰富的显示功能、更全面的保护机制等等。

(1) HAL 层 (hal.h 和 hal.c)

// hal.h - 硬件抽象层头文件
#ifndef HAL_H
#define HAL_H

#include <stdint.h>
#include <stdbool.h>

// GPIO 相关定义
typedef enum {
    GPIO_PIN_0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    // ... 更多 GPIO 引脚定义
    GPIO_PIN_MAX
} GPIO_PinTypeDef;

typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT
} GPIO_ModeTypeDef;

typedef enum {
    GPIO_STATE_RESET,
    GPIO_STATE_SET
} GPIO_StateTypeDef;

// ADC 相关定义
typedef enum {
    ADC_CHANNEL_0,
    ADC_CHANNEL_1,
    // ... 更多 ADC 通道定义
    ADC_CHANNEL_MAX
} ADC_ChannelTypeDef;

// DAC 相关定义
typedef enum {
    DAC_CHANNEL_0,
    // ... 更多 DAC 通道定义
    DAC_CHANNEL_MAX
} DAC_ChannelTypeDef;

// 定时器相关定义
typedef enum {
    TIMER_1,
    TIMER_2,
    // ... 更多定时器定义
    TIMER_MAX
} TimerTypeDef;

// HAL 层函数声明

// GPIO
void HAL_GPIO_Init(GPIO_PinTypeDef pin, GPIO_ModeTypeDef mode);
void HAL_GPIO_SetPinOutput(GPIO_PinTypeDef pin, GPIO_StateTypeDef state);
GPIO_StateTypeDef HAL_GPIO_ReadPinInput(GPIO_PinTypeDef pin);

// ADC
void HAL_ADC_Init(ADC_ChannelTypeDef channel);
uint16_t HAL_ADC_ReadChannel(ADC_ChannelTypeDef channel);

// DAC
void HAL_DAC_Init(DAC_ChannelTypeDef channel);
void HAL_DAC_SetValue(DAC_ChannelTypeDef channel, uint16_t value);

// 定时器
void HAL_Timer_Init(TimerTypeDef timer);
void HAL_Timer_Start(TimerTypeDef timer);
void HAL_Timer_Stop(TimerTypeDef timer);
uint32_t HAL_Timer_GetCounter(TimerTypeDef timer);
void HAL_Delay_ms(uint32_t ms);

#endif // HAL_H

// hal.c - 硬件抽象层实现文件 (平台相关代码，需要根据具体硬件平台实现)
#include "hal.h"

// 假设使用 STM32 平台，以下代码仅为示例，需要根据实际 STM32 型号和外设寄存器定义进行修改

// GPIO
void HAL_GPIO_Init(GPIO_PinTypeDef pin, GPIO_ModeTypeDef mode) {
    // ... 根据 pin 和 mode 配置 GPIO 寄存器 (例如 RCC, GPIOx_MODER, GPIOx_OTYPER, GPIOx_OSPEEDR, GPIOx_PUPDR)
    (void)pin; // 避免编译器警告 unused parameter
    (void)mode;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // 例如： RCC->AHB1ENR |= (1 << GPIO_PORT_CLOCK_ENABLE_BIT); // 使能 GPIO 时钟
    //       GPIOx->MODER &= ~(3 << (pin * 2)); // 清除模式位
    //       GPIOx->MODER |= (mode << (pin * 2));  // 设置模式
}

void HAL_GPIO_SetPinOutput(GPIO_PinTypeDef pin, GPIO_StateTypeDef state) {
    // ... 根据 pin 和 state 设置 GPIO 输出状态 (例如 GPIOx_ODR)
    (void)pin;
    (void)state;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // if (state == GPIO_STATE_SET) {
    //     GPIOx->BSRR = (1 << pin); // 设置引脚为高电平
    // } else {
    //     GPIOx->BSRR = (1 << (pin + 16)); // 设置引脚为低电平
    // }
}

GPIO_StateTypeDef HAL_GPIO_ReadPinInput(GPIO_PinTypeDef pin) {
    // ... 读取 GPIO 输入状态 (例如 GPIOx_IDR)
    (void)pin;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // if (GPIOx->IDR & (1 << pin)) {
    //     return GPIO_STATE_SET;
    // } else {
    //     return GPIO_STATE_RESET;
    // }
    return GPIO_STATE_RESET; // 示例，实际需要读取硬件状态
}

// ADC
void HAL_ADC_Init(ADC_ChannelTypeDef channel) {
    // ... 初始化 ADC 模块，配置通道 (例如 RCC, ADCx_CR2, ADCx_SQRx, ADCx_SMPRx)
    (void)channel;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // RCC->APB2ENR |= (1 << ADC_CLOCK_ENABLE_BIT); // 使能 ADC 时钟
    // ADCx->CR2 |= (1 << ADC_CR2_ADON_BIT); // 使能 ADC
    // ADCx->SQR1 = (channel << ADC_SQR1_SQ1_BIT); // 配置通道
    // ADCx->SMPR1 |= (ADC_SAMPLE_TIME << (channel * 3)); // 配置采样时间
}

uint16_t HAL_ADC_ReadChannel(ADC_ChannelTypeDef channel) {
    // ... 启动 ADC 转换，读取 ADC 值 (例如 ADCx_CR2, ADCx_SR, ADCx_DR)
    (void)channel;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // ADCx->CR2 |= (1 << ADC_CR2_SWSTART_BIT); // 启动转换
    // while (!(ADCx->SR & (1 << ADC_SR_EOC_BIT))); // 等待转换完成
    // return ADCx->DR; // 返回 ADC 值
    return 0; // 示例，实际需要读取硬件值
}

// DAC
void HAL_DAC_Init(DAC_ChannelTypeDef channel) {
    // ... 初始化 DAC 模块，配置通道 (例如 RCC, DACx_CR, DACx_DHRx)
    (void)channel;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // RCC->APB1ENR |= (1 << DAC_CLOCK_ENABLE_BIT); // 使能 DAC 时钟
    // DACx->CR |= (1 << DAC_CR_EN1_BIT); // 使能 DAC 通道
}

void HAL_DAC_SetValue(DAC_ChannelTypeDef channel, uint16_t value) {
    // ... 设置 DAC 输出值 (例如 DACx_DHRx)
    (void)channel;
    (void)value;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // DACx->DHR12R1 = value; // 设置 DAC 值 (12 位分辨率)
}

// 定时器
void HAL_Timer_Init(TimerTypeDef timer) {
    // ... 初始化定时器模块 (例如 RCC, TIMx_CR1, TIMx_PSC, TIMx_ARR)
    (void)timer;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // RCC->APB1ENR |= (1 << TIMER_CLOCK_ENABLE_BIT); // 使能定时器时钟
    // TIMx->PSC = PRESCALER_VALUE; // 设置预分频器
    // TIMx->ARR = AUTORELOAD_VALUE; // 设置自动重装载值
}

void HAL_Timer_Start(TimerTypeDef timer) {
    // ... 启动定时器 (例如 TIMx_CR1)
    (void)timer;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // TIMx->CR1 |= (1 << TIM_CR1_CEN_BIT); // 启动定时器
}

void HAL_Timer_Stop(TimerTypeDef timer) {
    // ... 停止定时器 (例如 TIMx_CR1)
    (void)timer;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // TIMx->CR1 &= ~(1 << TIM_CR1_CEN_BIT); // 停止定时器
}

uint32_t HAL_Timer_GetCounter(TimerTypeDef timer) {
    // ... 获取定时器计数值 (例如 TIMx_CNT)
    (void)timer;
    // 示例代码，实际需要根据 STM32 寄存器定义进行配置
    // return TIMx->CNT; // 返回计数器值
    return 0; // 示例，实际需要读取硬件值
}

void HAL_Delay_ms(uint32_t ms) {
    // ... 毫秒级延时函数 (可以使用 SysTick 或 定时器实现)
    (void)ms;
    // 简单延时示例，实际应用中建议使用更精确的延时方法
    volatile uint32_t count = ms * 1000; // 粗略延时，需要根据实际时钟频率调整
    while (count--) {
        __NOP(); // 空操作
    }
}

(2) 驱动层 (driver.h 和 driver.c)

// driver.h - 驱动层头文件
#ifndef DRIVER_H
#define DRIVER_H

#include <stdint.h>
#include <stdbool.h>
#include "hal.h"

// ADC 驱动接口
typedef enum {
    ADC_CHANNEL_VOLTAGE,
    ADC_CHANNEL_CURRENT,
    ADC_CHANNEL_COUNT
} ADC_UserChannelTypeDef;

void ADC_Driver_Init(ADC_UserChannelTypeDef channel);
uint16_t ADC_Driver_ReadValue(ADC_UserChannelTypeDef channel);

// DAC 驱动接口
typedef enum {
    DAC_CHANNEL_CURRENT_CONTROL,
    DAC_CHANNEL_COUNT
} DAC_UserChannelTypeDef;

void DAC_Driver_Init(DAC_UserChannelTypeDef channel);
void DAC_Driver_SetValue(DAC_UserChannelTypeDef channel, uint16_t value);

// GPIO 驱动接口 (按钮)
typedef enum {
    BUTTON_SET,
    BUTTON_UP,
    BUTTON_DOWN,
    BUTTON_COUNT
} ButtonTypeDef;

void Button_Driver_Init(ButtonTypeDef button);
bool Button_Driver_GetState(ButtonTypeDef button);

// 显示屏驱动接口 (假设使用 SPI 接口的 LCD)
void Display_Driver_Init(void);
void Display_Driver_WriteString(const char *str, uint16_t x, uint16_t y);
void Display_Driver_ClearScreen(void);
void Display_Driver_DrawPixel(uint16_t x, uint16_t y, uint16_t color); // 示例函数，可以根据实际显示屏驱动能力扩展

#endif // DRIVER_H

// driver.c - 驱动层实现文件
#include "driver.h"

// ADC 驱动实现
void ADC_Driver_Init(ADC_UserChannelTypeDef channel) {
    if (channel == ADC_CHANNEL_VOLTAGE) {
        HAL_ADC_Init(ADC_CHANNEL_0); // 假设电压通道连接到 ADC 通道 0
    } else if (channel == ADC_CHANNEL_CURRENT) {
        HAL_ADC_Init(ADC_CHANNEL_1); // 假设电流通道连接到 ADC 通道 1
    }
    // ... 可以添加更多初始化配置，例如校准、采样率配置等
}

uint16_t ADC_Driver_ReadValue(ADC_UserChannelTypeDef channel) {
    if (channel == ADC_CHANNEL_VOLTAGE) {
        return HAL_ADC_ReadChannel(ADC_CHANNEL_0);
    } else if (channel == ADC_CHANNEL_CURRENT) {
        return HAL_ADC_ReadChannel(ADC_CHANNEL_1);
    }
    return 0; // 错误或无效通道
}

// DAC 驱动实现
void DAC_Driver_Init(DAC_UserChannelTypeDef channel) {
    if (channel == DAC_CHANNEL_CURRENT_CONTROL) {
        HAL_DAC_Init(DAC_CHANNEL_0); // 假设电流控制 DAC 连接到 DAC 通道 0
    }
    // ... 可以添加更多初始化配置，例如输出缓冲使能等
}

void DAC_Driver_SetValue(DAC_UserChannelTypeDef channel, uint16_t value) {
    if (channel == DAC_CHANNEL_CURRENT_CONTROL) {
        HAL_DAC_SetValue(DAC_CHANNEL_0, value);
    }
}

// GPIO 驱动实现 (按钮)
void Button_Driver_Init(ButtonTypeDef button) {
    if (button == BUTTON_SET) {
        HAL_GPIO_Init(GPIO_PIN_0, GPIO_MODE_INPUT); // 假设 SET 按钮连接到 GPIO_PIN_0
    } else if (button == BUTTON_UP) {
        HAL_GPIO_Init(GPIO_PIN_1, GPIO_MODE_INPUT); // 假设 UP 按钮连接到 GPIO_PIN_1
    } else if (button == BUTTON_DOWN) {
        HAL_GPIO_Init(GPIO_PIN_2, GPIO_MODE_INPUT); // 假设 DOWN 按钮连接到 GPIO_PIN_2
    }
    // ... 可以添加上拉或下拉电阻配置
}

bool Button_Driver_GetState(ButtonTypeDef button) {
    GPIO_PinTypeDef gpio_pin;
    if (button == BUTTON_SET) {
        gpio_pin = GPIO_PIN_0;
    } else if (button == BUTTON_UP) {
        gpio_pin = GPIO_PIN_1;
    } else if (button == BUTTON_DOWN) {
        gpio_pin = GPIO_PIN_2;
    } else {
        return false; // 无效按钮
    }
    return (HAL_GPIO_ReadPinInput(gpio_pin) == GPIO_STATE_RESET); // 假设按钮按下时 GPIO 为低电平
}

// 显示屏驱动实现 (示例，需要根据实际显示屏驱动 IC 和接口协议实现)
void Display_Driver_Init(void) {
    // ... 初始化 SPI 接口，配置 SPI 参数
    // ... 初始化 LCD 控制器，例如发送初始化命令序列
}

void Display_Driver_WriteString(const char *str, uint16_t x, uint16_t y) {
    // ... 在 (x, y) 位置显示字符串 str
    // ... 需要根据显示屏的字符编码和字体库实现
    (void)str;
    (void)x;
    (void)y;
    // 示例： 循环发送字符数据到 SPI 接口，控制 LCD 显示
}

void Display_Driver_ClearScreen(void) {
    // ... 清空屏幕，填充背景色
}

void Display_Driver_DrawPixel(uint16_t x, uint16_t y, uint16_t color) {
    // ... 在 (x, y) 位置绘制像素点，颜色为 color
}

(3) 服务层 (service.h 和 service.c)

// service.h - 服务层头文件
#ifndef SERVICE_H
#define SERVICE_H

#include <stdint.h>
#include <stdbool.h>

// 电流控制服务接口
void CurrentControl_Service_Init(void);
void CurrentControl_Service_SetCurrent(uint16_t mA); // 设置目标电流，单位 mA
void CurrentControl_Service_EnableOutput(void);
void CurrentControl_Service_DisableOutput(void);
uint16_t CurrentControl_Service_GetOutputCurrent(void); // 获取实际输出电流，单位 mA

// 电压/电流测量服务接口
void Measurement_Service_Init(void);
uint16_t Measurement_Service_GetVoltage(void); // 获取输入电压，单位 mV
uint16_t Measurement_Service_GetCurrent(void); // 获取实际输出电流，单位 mA

// 按键输入服务接口
typedef enum {
    BUTTON_EVENT_NONE,
    BUTTON_EVENT_SET_CLICK,
    BUTTON_EVENT_UP_CLICK,
    BUTTON_EVENT_DOWN_CLICK
} ButtonEventType;

void Button_Service_Init(void);
ButtonEventType Button_Service_GetEvent(void);

// 显示服务接口
void Display_Service_Init(void);
void Display_Service_ShowCurrentSetting(uint16_t mA);
void Display_Service_ShowVoltage(uint16_t mV);
void Display_Service_ShowOutputCurrent(uint16_t mA);
void Display_Service_ShowStatusMessage(const char *message);
void Display_Service_ClearDisplay(void);

// 保护机制服务接口
void Protection_Service_Init(void);
void Protection_Service_EnableOverCurrentProtection(uint16_t threshold_mA);
void Protection_Service_DisableOverCurrentProtection(void);
bool Protection_Service_IsOverCurrent(void);

#endif // SERVICE_H

// service.c - 服务层实现文件
#include "service.h"
#include "driver.h"
#include "hal.h"

// 电流控制服务实现
#define TARGET_CURRENT_MAX_MA  3000
#define TARGET_CURRENT_MIN_MA  20

static uint16_t target_current_mA = 1000; // 默认目标电流 1A
static bool output_enabled = false;

void CurrentControl_Service_Init(void) {
    DAC_Driver_Init(DAC_CHANNEL_CURRENT_CONTROL);
    ADC_Driver_Init(ADC_CHANNEL_CURRENT);
    // ... 初始化 PID 控制器参数
}

void CurrentControl_Service_SetCurrent(uint16_t mA) {
    if (mA > TARGET_CURRENT_MAX_MA) {
        target_current_mA = TARGET_CURRENT_MAX_MA;
    } else if (mA < TARGET_CURRENT_MIN_MA) {
        target_current_mA = TARGET_CURRENT_MIN_MA;
    } else {
        target_current_mA = mA;
    }
    // ... 可以添加电流设置范围检查和错误处理
}

void CurrentControl_Service_EnableOutput(void) {
    output_enabled = true;
    // ... 启动 PID 控制循环或定时器，开始电流控制
    // ... 设置 DAC 输出，启动电流输出
    DAC_Driver_SetValue(DAC_CHANNEL_CURRENT_CONTROL, 2048); // 示例：设置 DAC 中间值 (假设 12 位 DAC)
}

void CurrentControl_Service_DisableOutput(void) {
    output_enabled = false;
    // ... 停止 PID 控制循环或定时器
    // ... 关闭 DAC 输出，停止电流输出
    DAC_Driver_SetValue(DAC_CHANNEL_CURRENT_CONTROL, 0); // 设置 DAC 输出为 0
}

uint16_t CurrentControl_Service_GetOutputCurrent(void) {
    // ... 读取 ADC 采样值，转换为电流值 (mA)
    uint16_t adc_value = ADC_Driver_ReadValue(ADC_CHANNEL_CURRENT);
    // ... 根据 ADC 值和电流采样电阻的参数进行转换
    // ... 可以添加滤波和校准处理
    return (uint16_t)(((uint32_t)adc_value * 3000) / 4095); // 示例：假设 ADC 满量程对应 3A
}

// 电压/电流测量服务实现
void Measurement_Service_Init(void) {
    ADC_Driver_Init(ADC_CHANNEL_VOLTAGE);
    ADC_Driver_Init(ADC_CHANNEL_CURRENT);
}

uint16_t Measurement_Service_GetVoltage(void) {
    uint16_t adc_value = ADC_Driver_ReadValue(ADC_CHANNEL_VOLTAGE);
    // ... 根据 ADC 值和分压电阻的参数进行转换，转换为电压值 (mV)
    // ... 可以添加滤波和校准处理
    return (uint16_t)(((uint32_t)adc_value * 35000) / 4095); // 示例：假设 ADC 满量程对应 35V
}

uint16_t Measurement_Service_GetCurrent(void) {
    return CurrentControl_Service_GetOutputCurrent(); // 直接调用电流控制服务获取电流值
}

// 按键输入服务实现
static ButtonEventType current_button_event = BUTTON_EVENT_NONE;

void Button_Service_Init(void) {
    Button_Driver_Init(BUTTON_SET);
    Button_Driver_Init(BUTTON_UP);
    Button_Driver_Init(BUTTON_DOWN);
}

ButtonEventType Button_Service_GetEvent(void) {
    ButtonEventType event = current_button_event;
    current_button_event = BUTTON_EVENT_NONE; // 清除事件标志
    return event;
}

// (需要在主循环或定时器中断中定期轮询按键状态，检测按键事件)
void Button_Service_PollButtons(void) {
    static bool set_button_pressed = false;
    static bool up_button_pressed = false;
    static bool down_button_pressed = false;

    // SET 按钮
    bool set_button_state = Button_Driver_GetState(BUTTON_SET);
    if (set_button_state && !set_button_pressed) {
        current_button_event = BUTTON_EVENT_SET_CLICK;
        set_button_pressed = true;
    } else if (!set_button_state) {
        set_button_pressed = false;
    }

    // UP 按钮
    bool up_button_state = Button_Driver_GetState(BUTTON_UP);
    if (up_button_state && !up_button_pressed) {
        current_button_event = BUTTON_EVENT_UP_CLICK;
        up_button_pressed = true;
    } else if (!up_button_state) {
        up_button_pressed = false;
    }

    // DOWN 按钮
    bool down_button_state = Button_Driver_GetState(BUTTON_DOWN);
    if (down_button_state && !down_button_pressed) {
        current_button_event = BUTTON_EVENT_DOWN_CLICK;
        down_button_pressed = true;
    } else if (!down_button_state) {
        down_button_pressed = false;
    }
}

// 显示服务实现
void Display_Service_Init(void) {
    Display_Driver_Init();
    Display_Driver_ClearScreen();
}

void Display_Service_ShowCurrentSetting(uint16_t mA) {
    char buffer[32];
    sprintf(buffer, "Set: %d mA", mA);
    Display_Driver_WriteString(buffer, 0, 0);
}

void Display_Service_ShowVoltage(uint16_t mV) {
    char buffer[32];
    sprintf(buffer, "Vin: %.2f V", (float)mV / 1000.0f);
    Display_Driver_WriteString(buffer, 0, 16); // 假设每行 16 像素高度
}

void Display_Service_ShowOutputCurrent(uint16_t mA) {
    char buffer[32];
    sprintf(buffer, "Iout: %.2f A", (float)mA / 1000.0f);
    Display_Driver_WriteString(buffer, 0, 32);
}

void Display_Service_ShowStatusMessage(const char *message) {
    Display_Driver_WriteString(message, 0, 48); // 假设状态信息显示在第四行
}

void Display_Service_ClearDisplay(void) {
    Display_Driver_ClearScreen();
}

// 保护机制服务实现
#define OVER_CURRENT_THRESHOLD_DEFAULT_MA 3500 // 默认过流阈值 3.5A
static uint16_t over_current_threshold_mA = OVER_CURRENT_THRESHOLD_DEFAULT_MA;
static bool over_current_protection_enabled = true;
static bool is_over_current_flag = false;

void Protection_Service_Init(void) {
    // ... 初始化保护机制相关参数
}

void Protection_Service_EnableOverCurrentProtection(uint16_t threshold_mA) {
    over_current_protection_enabled = true;
    over_current_threshold_mA = threshold_mA;
}

void Protection_Service_DisableOverCurrentProtection(void) {
    over_current_protection_enabled = false;
}

bool Protection_Service_IsOverCurrent(void) {
    return is_over_current_flag;
}

// (需要在主循环或定时器中断中定期检查电流值，检测过流)
void Protection_Service_CheckCurrent(void) {
    if (!over_current_protection_enabled) return;

    uint16_t current_mA = Measurement_Service_GetCurrent();
    if (current_mA > over_current_threshold_mA) {
        is_over_current_flag = true;
        CurrentControl_Service_DisableOutput(); // 触发过流保护，关闭输出
        Display_Service_ShowStatusMessage("Over Current Protection!");
        // ... 可以添加报警或指示灯等
    } else {
        is_over_current_flag = false;
    }
}

(4) 应用层 (application.c - main 函数)

// application.c - 应用层实现，main 函数
#include "service.h"
#include "hal.h"
#include <stdio.h>

int main(void) {
    // 初始化 HAL 层 (平台相关的初始化)
    // ... 系统时钟初始化，外设时钟使能等

    // 初始化服务层
    Display_Service_Init();
    Measurement_Service_Init();
    CurrentControl_Service_Init();
    Button_Service_Init();
    Protection_Service_Init();

    Display_Service_ShowStatusMessage("Programmable Current Meter");
    HAL_Delay_ms(2000);
    Display_Service_ClearDisplay();

    uint16_t current_setting = 1000; // 初始电流设置 1A
    CurrentControl_Service_SetCurrent(current_setting);
    Display_Service_ShowCurrentSetting(current_setting);

    while (1) {
        // 轮询按键事件
        Button_Service_PollButtons();
        ButtonEventType event = Button_Service_GetEvent();
        if (event == BUTTON_EVENT_SET_CLICK) {
            CurrentControl_Service_EnableOutput();
            Display_Service_ShowStatusMessage("Output Enabled");
        } else if (event == BUTTON_EVENT_UP_CLICK) {
            current_setting += 100; // 每次增加 100mA
            if (current_setting > 3000) current_setting = 3000;
            CurrentControl_Service_SetCurrent(current_setting);
            Display_Service_ShowCurrentSetting(current_setting);
        } else if (event == BUTTON_EVENT_DOWN_CLICK) {
            current_setting -= 100; // 每次减少 100mA
            if (current_setting < 20) current_setting = 20;
            CurrentControl_Service_SetCurrent(current_setting);
            Display_Service_ShowCurrentSetting(current_setting);
        }

        // 定期更新显示
        Display_Service_ShowVoltage(Measurement_Service_GetVoltage());
        Display_Service_ShowOutputCurrent(Measurement_Service_GetCurrent());

        // 检测过流保护
        Protection_Service_CheckCurrent();

        HAL_Delay_ms(100); // 循环延时
    }
}

代码说明:

• 代码框架: 以上代码提供了嵌入式软件系统的分层架构框架，包括 HAL 层、驱动层、服务层和应用层，以及各个层的头文件和源文件示例。
• 模块化设计: 代码按照模块化设计，每个模块负责特定的功能，例如 ADC 驱动、DAC 驱动、电流控制服务、显示服务等。
• 接口清晰: 各层之间通过头文件中定义的接口进行交互，降低了模块之间的耦合度。
• 可扩展性: 分层架构和模块化设计使得系统易于扩展和维护。例如，如果需要更换显示屏，只需要修改显示屏驱动模块即可，上层代码无需改动。
• 代码不完整: 以上代码只是示例框架，为了达到 3000 行代码的要求，需要根据具体的硬件平台和功能需求，填充各个模块的具体实现代码，包括更详细的初始化配置、错误处理、PID 控制算法的具体实现、更丰富的显示功能、更全面的保护机制等等。例如：
  • PID 控制算法实现: 在 CurrentControl_Service_SetCurrent() 和 CurrentControl_Service_EnableOutput() 中需要实现 PID 控制算法，根据目标电流和实际电流的偏差，调整 DAC 输出值，实现精确的电流控制。
  • 更详细的显示功能: Display_Driver_WriteString() 需要根据实际显示屏的驱动方式和字符编码实现字符串显示功能。可以扩展显示数字、图标、菜单等功能。
  • 更完善的保护机制: 可以添加过压保护、短路保护、过温保护等机制。
  • 错误处理: 在各个模块中添加错误检测和错误处理代码，例如 ADC 采样错误、DAC 输出错误、按键输入错误等。
  • 参数配置: 可以将一些参数 (例如 PID 参数、过流阈值、显示参数等) 放在配置文件中，方便用户配置和修改。
  • 用户交互: 可以扩展用户交互功能，例如通过按键设置过流阈值、调整显示亮度、切换显示模式等。
  • 数据记录: 可以添加数据记录功能，将电压、电流等数据记录到存储介质 (例如 Flash 或 SD 卡) 中，方便数据分析和故障排查。

总结

这个可编程电流表嵌入式系统项目采用分层架构进行软件设计，确保了系统的可靠性、高效性和可扩展性。通过模块化编程、清晰的接口设计和关键技术的应用，我们构建了一个完整的嵌入式系统开发流程。 示例代码框架展示了系统架构和关键模块的实现思路。为了实现一个功能完善、代码量达到 3000 行以上的完整项目，还需要根据具体的硬件平台和功能需求，进一步完善各个模块的代码实现，添加更多的功能和细节。 这个项目展示了作为一个高级嵌入式软件开发工程师，如何从需求分析出发，设计系统架构，选择合适的技术和方法，最终实现一个可靠、高效、可扩展的嵌入式系统产品。