编程技术分享

分享编程知识，探讨技术创新

0%

简介：设计一数字BOOST电路，用LCD显示电源模式及性能参数。

发表于 分类于 ， ，

好的，作为一名高级嵌入式软件开发工程师，非常荣幸能为您详细解析并设计一个数字 BOOST 电路的嵌入式系统方案，并提供相应的 C 代码实现。本项目旨在展示一个从需求分析到最终实现的完整嵌入式系统开发流程，力求打造一个可靠、高效、可扩展的系统平台。
关注微信公众号，提前获取相关推文

项目背景与需求分析

项目名称: 数字 BOOST 电路智能控制与显示系统

项目目标:

  1. 设计并实现一个数字控制的 BOOST 电路: 能够将输入的较低电压提升至用户设定的较高电压，并保持输出电压的稳定。
  2. 实时监控与显示: 通过 LCD 屏幕实时显示 BOOST 电路的电源模式（例如：恒压模式、恒流模式等）以及关键性能参数，如输入电压、输出电压、输出电流、功率、效率等。
  3. 用户交互界面: 通过按键提供友好的用户交互界面，允许用户设置目标输出电压、选择工作模式、查看系统信息等。
  4. 系统可靠性与稳定性: 确保系统在各种工况下都能稳定可靠运行，具备一定的保护机制，例如过压保护、过流保护、过温保护等。
  5. 系统高效性: 优化 BOOST 电路的设计和控制算法，提高能量转换效率，降低系统功耗。
  6. 系统可扩展性: 采用模块化设计，方便后续功能扩展和升级，例如增加数据记录、远程监控等功能。

需求细化:

  • 输入电压范围: 假设输入电压范围为 3V - 5V (可根据实际应用场景调整)。
  • 输出电压范围: 假设输出电压范围为 5V - 12V (可根据实际应用场景调整)。
  • 输出电流能力: 假设输出电流能力为 1A (可根据实际应用场景调整)。
  • 电压精度: 输出电压精度要求在 ±1% 以内。
  • 电流精度: 输出电流精度要求在 ±2% 以内。
  • 显示参数: LCD 需显示以下参数：
    • 电源模式 (例如：恒压 CV, 恒流 CC)
    • 设定输出电压 (V_set)
    • 实际输出电压 (V_out)
    • 实际输出电流 (I_out)
    • 输入电压 (V_in)
    • 输出功率 (P_out)
    • 转换效率 (Efficiency)
  • 用户交互: 通过按键实现以下功能：
    • 模式切换 (恒压模式/恒流模式等)
    • 设定输出电压/电流值
    • 菜单导航 (查看系统信息、设置参数等)
  • 保护功能:
    • 过压保护 (OVP)
    • 过流保护 (OCP)
    • 过温保护 (OTP)
    • 输入欠压保护 (UVP)

系统设计架构

为了实现上述需求，并确保系统可靠、高效、可扩展，我们采用分层架构和模块化设计的思想来构建嵌入式软件系统。这种架构将系统划分为不同的层次和模块，每个层次和模块负责特定的功能，降低了系统的复杂性，提高了代码的可维护性和可重用性。

系统架构图:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
+---------------------+
|   Application Layer   |  <--- 用户界面、模式管理、应用逻辑
+---------------------+
         |
+---------------------+
|  Power Mgmt Layer   |  <--- 电源模式控制、参数配置、保护机制
+---------------------+
         |
+---------------------+
|  BOOST Ctrl Layer   |  <--- BOOST 电路控制算法 (PID 等)、PWM 生成、反馈处理
+---------------------+
         |
+---------------------+
| Device Driver Layer |  <--- ADC 驱动、PWM 驱动、LCD 驱动、GPIO 驱动
+---------------------+
         |
+---------------------+
|  Hardware Abstraction|  <--- MCU 硬件外设的抽象层，与具体 MCU 平台相关
|     Layer (HAL)     |
+---------------------+
         |
+---------------------+
|      Hardware       |  <--- MCU, BOOST 电路硬件, LCD, 按键, 传感器
+---------------------+

各层功能描述:

  1. 硬件层 (Hardware): 包括微控制器 (MCU)、BOOST 电路硬件 (功率 MOSFET, 电感, 二极管, 电容等)、LCD 显示屏、按键输入、以及必要的传感器 (电压传感器、电流传感器、温度传感器等)。

  2. 硬件抽象层 (HAL - Hardware Abstraction Layer): HAL 层是直接与硬件交互的软件层，它将 MCU 硬件外设的操作抽象成统一的 API 接口，使得上层软件可以独立于具体的 MCU 平台进行开发。HAL 层通常包括 GPIO 初始化/控制、ADC 初始化/读取、PWM 初始化/控制、定时器初始化/控制、SPI/I2C 等通信接口驱动等。HAL 层的实现会高度依赖于所选用的 MCU 平台。

  3. 设备驱动层 (Device Driver Layer): 设备驱动层构建在 HAL 层之上，提供更高级、更易用的设备驱动接口。例如，ADC 驱动可以提供读取电压值的函数，PWM 驱动可以提供设置 PWM 占空比的函数，LCD 驱动可以提供显示字符、字符串、数字等函数。设备驱动层隐藏了底层硬件操作的细节，使得上层软件开发更加高效。

  4. BOOST 控制层 (BOOST Control Layer): BOOST 控制层是系统的核心层，负责实现 BOOST 电路的数字控制算法。它接收来自设备驱动层的 ADC 采样数据 (输出电压、输出电流、输入电压等)，根据设定的控制策略 (例如 PID 控制)，计算出合适的 PWM 占空比，并通过 PWM 驱动层控制 BOOST 电路的 MOSFET 开关，从而实现对输出电压的精确调节。同时，BOOST 控制层还需要实现各种保护机制，例如过压保护、过流保护等。

  5. 电源管理层 (Power Management Layer): 电源管理层负责管理系统的电源模式 (例如恒压模式、恒流模式、待机模式等)、参数配置 (例如设定输出电压、输出电流限制、保护阈值等) 以及各种保护机制的协调和处理。它接收来自应用层的模式切换和参数设置指令，并将其传递给 BOOST 控制层和设备驱动层。同时，电源管理层还需要监控系统的状态，并在检测到异常情况时触发相应的保护动作。

  6. 应用层 (Application Layer): 应用层是系统的最高层，负责实现用户界面、模式管理、应用逻辑等功能。它包括用户交互界面 (按键处理、菜单显示)、显示参数更新、系统状态监控、以及一些高级应用功能 (例如数据记录、远程控制接口等)。应用层通过调用电源管理层提供的接口来控制系统的运行模式和参数。

关键技术与方法

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

  1. 数字 PID 控制算法: 采用数字 PID (比例-积分-微分) 控制算法来实现对 BOOST 电路输出电压的精确调节。PID 控制算法是一种经典的闭环控制算法，具有结构简单、参数整定方便、鲁棒性好等优点，广泛应用于各种工业控制系统中。我们将根据 BOOST 电路的特性，仔细整定 PID 参数，以获得最佳的控制性能。

  2. PWM (脉冲宽度调制) 技术: 利用 MCU 的硬件 PWM 模块生成可调占空比的 PWM 信号，来驱动 BOOST 电路中的 MOSFET 开关。PWM 技术是数字控制功率电子电路的核心技术，通过调节 PWM 信号的占空比，可以有效地控制功率器件的导通时间，从而实现对输出电压或电流的调节。

  3. ADC (模数转换器) 数据采集: 使用 MCU 的 ADC 模块采集 BOOST 电路的输出电压、输出电流、输入电压等模拟信号，将其转换为数字信号，供 BOOST 控制层进行计算和控制。高精度的 ADC 采样是实现精确控制的基础。

  4. LCD 显示驱动技术: 选择合适的 LCD 驱动芯片和库，实现 LCD 屏幕的初始化、字符/字符串显示、数字显示、图形显示等功能，为用户提供友好的信息显示界面。

  5. 按键输入处理技术: 采用轮询或中断方式检测按键输入，并进行按键去抖动处理，确保按键输入的可靠性。通过按键实现用户交互功能，例如模式切换、参数设置、菜单导航等。

  6. 模块化编程与分层架构: 将系统软件划分为不同的模块和层次，每个模块和层次负责特定的功能，模块之间通过定义良好的接口进行通信。这种模块化和分层架构可以提高代码的可维护性、可重用性和可扩展性，方便后续的功能扩展和升级。

  7. 状态机设计模式: 使用状态机设计模式来管理系统的不同工作模式 (例如：恒压模式、恒流模式、待机模式等)。状态机可以清晰地描述系统在不同状态之间的转换逻辑，提高代码的可读性和可维护性。

  8. 异常处理与保护机制: 在软件设计中充分考虑各种异常情况，例如输入电压过低、输出电压过高、输出电流过大、温度过高等，并设计相应的保护机制，例如过压保护 (OVP)、过流保护 (OCP)、过温保护 (OTP)、输入欠压保护 (UVP) 等，以确保系统的安全可靠运行。

  9. 代码版本管理与文档编写: 使用 Git 等版本管理工具进行代码版本管理，方便代码的维护和协作开发。同时，编写详细的软件设计文档、代码注释、用户手册等，方便代码的理解、维护和使用。

具体 C 代码实现 (示例代码，仅供参考，需要根据具体的 MCU 平台和硬件电路进行调整)

由于代码量较大，这里只提供关键模块的 C 代码示例，完整代码需要根据具体的硬件平台和需求进行详细编写。以下代码示例基于一个假设的 MCU 平台 (例如 STM32) 和 LCD 驱动库。

1. HAL 层代码示例 (hal_gpio.h, hal_adc.h, hal_pwm.h, hal_timer.h, hal_lcd.h):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
// hal_gpio.h
#ifndef HAL_GPIO_H
#define HAL_GPIO_H

typedef enum {
    GPIO_PIN_0,
    GPIO_PIN_1,
    GPIO_PIN_2,
    // ... more pins
    GPIO_PIN_MAX
} GPIO_PinTypeDef;

typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT,
    // ... more modes
} GPIO_ModeTypeDef;

typedef enum {
    GPIO_SPEED_LOW,
    GPIO_SPEED_MEDIUM,
    GPIO_SPEED_HIGH,
    // ... more speeds
} GPIO_SpeedTypeDef;

typedef enum {
    GPIO_PULL_NONE,
    GPIO_PULL_UP,
    GPIO_PULL_DOWN,
    // ... more pull modes
} GPIO_PuPdTypeDef;

void HAL_GPIO_Init(GPIO_PinTypeDef GPIO_Pin, GPIO_ModeTypeDef GPIO_Mode, GPIO_SpeedTypeDef GPIO_Speed, GPIO_PuPdTypeDef GPIO_PuPd);
void HAL_GPIO_WritePin(GPIO_PinTypeDef GPIO_Pin, uint8_t PinState); // 0 or 1
uint8_t HAL_GPIO_ReadPin(GPIO_PinTypeDef GPIO_Pin);

#endif // HAL_GPIO_H

// hal_adc.h
#ifndef HAL_ADC_H
#define HAL_ADC_H

typedef enum {
    ADC_CHANNEL_0,
    ADC_CHANNEL_1,
    ADC_CHANNEL_2,
    // ... more channels
    ADC_CHANNEL_MAX
} ADC_ChannelTypeDef;

void HAL_ADC_Init(ADC_ChannelTypeDef ADC_Channel);
uint16_t HAL_ADC_GetValue(ADC_ChannelTypeDef ADC_Channel); // 12-bit ADC value

#endif // HAL_ADC_H

// hal_pwm.h
#ifndef HAL_PWM_H
#define HAL_PWM_H

typedef enum {
    PWM_CHANNEL_1,
    PWM_CHANNEL_2,
    // ... more channels
    PWM_CHANNEL_MAX
} PWM_ChannelTypeDef;

void HAL_PWM_Init(PWM_ChannelTypeDef PWM_Channel, uint32_t frequency); // Frequency in Hz
void HAL_PWM_SetDutyCycle(PWM_ChannelTypeDef PWM_Channel, float dutyCycle); // Duty cycle from 0.0 to 1.0

#endif // HAL_PWM_H

// hal_timer.h (示例 - 简单延时函数)
#ifndef HAL_TIMER_H
#define HAL_TIMER_H

void HAL_Delay_ms(uint32_t milliseconds);

#endif // HAL_TIMER_H

// hal_lcd.h (假设使用 SPI 接口的 LCD)
#ifndef HAL_LCD_H
#define HAL_LCD_H

void HAL_LCD_Init(void);
void HAL_LCD_Clear(void);
void HAL_LCD_SetCursor(uint8_t row, uint8_t col);
void HAL_LCD_WriteString(const char *str);
void HAL_LCD_WriteChar(char ch);
void HAL_LCD_WriteNumber(uint32_t num);

#endif // HAL_LCD_H

2. 设备驱动层代码示例 (drv_adc.h, drv_pwm.h, drv_lcd.h, drv_button.h):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
// drv_adc.h
#ifndef DRV_ADC_H
#define DRV_ADC_H

#include "hal_adc.h"

void DRV_ADC_Init(void);
float DRV_ADC_ReadVoltage(ADC_ChannelTypeDef channel); // Return voltage in Volts
float DRV_ADC_ReadCurrent(ADC_ChannelTypeDef channel); // Return current in Amperes

#endif // DRV_ADC_H

// drv_adc.c
#include "drv_adc.h"
#include "hal_adc.h"

#define ADC_RESOLUTION  4096.0f // 12-bit ADC
#define VREF            3.3f    // Reference voltage

void DRV_ADC_Init(void) {
    HAL_ADC_Init(ADC_CHANNEL_0); // Example: Channel for voltage feedback
    HAL_ADC_Init(ADC_CHANNEL_1); // Example: Channel for current feedback
    // ... initialize other ADC channels if needed
}

float DRV_ADC_ReadVoltage(ADC_ChannelTypeDef channel) {
    uint16_t adcValue = HAL_ADC_GetValue(channel);
    return (float)adcValue * VREF / ADC_RESOLUTION;
}

float DRV_ADC_ReadCurrent(ADC_ChannelTypeDef channel) {
    uint16_t adcValue = HAL_ADC_GetValue(channel);
    // Assuming a current shunt resistor is used, and known shunt resistance value
    float shuntResistance = 0.1f; // Example: 0.1 Ohm shunt resistor
    float voltageAcrossShunt = (float)adcValue * VREF / ADC_RESOLUTION;
    return voltageAcrossShunt / shuntResistance;
}


// drv_pwm.h
#ifndef DRV_PWM_H
#define DRV_PWM_H

#include "hal_pwm.h"

void DRV_PWM_Init(void);
void DRV_PWM_SetBoostDutyCycle(float dutyCycle); // Duty cycle for BOOST MOSFET control

#endif // DRV_PWM_H

// drv_pwm.c
#include "drv_pwm.h"
#include "hal_pwm.h"

#define PWM_FREQUENCY_BOOST 100000 // 100kHz PWM frequency for BOOST

void DRV_PWM_Init(void) {
    HAL_PWM_Init(PWM_CHANNEL_1, PWM_FREQUENCY_BOOST); // Example: PWM channel for BOOST control
    HAL_PWM_SetDutyCycle(PWM_CHANNEL_1, 0.0f); // Initialize duty cycle to 0
}

void DRV_PWM_SetBoostDutyCycle(float dutyCycle) {
    // Duty cycle should be within 0.0 to 1.0 range, and potentially clamp values
    if (dutyCycle < 0.0f) dutyCycle = 0.0f;
    if (dutyCycle > 0.95f) dutyCycle = 0.95f; // Avoid 100% duty cycle in BOOST
    HAL_PWM_SetDutyCycle(PWM_CHANNEL_1, dutyCycle);
}


// drv_lcd.h (假设使用自定义 LCD 驱动)
#ifndef DRV_LCD_H
#define DRV_LCD_H

void DRV_LCD_Init(void);
void DRV_LCD_DisplayPowerMode(const char *mode);
void DRV_LCD_DisplayVoltage(float vSet, float vOut, float vIn);
void DRV_LCD_DisplayCurrent(float iOut);
void DRV_LCD_DisplayPower(float pOut);
void DRV_LCD_DisplayEfficiency(float efficiency);
void DRV_LCD_ClearScreen(void);

#endif // DRV_LCD_H

// drv_lcd.c (简略示例 - 需要根据实际 LCD 驱动库实现)
#include "drv_lcd.h"
#include "hal_lcd.h"
#include <stdio.h> // For sprintf

void DRV_LCD_Init(void) {
    HAL_LCD_Init();
    DRV_LCD_ClearScreen();
}

void DRV_LCD_ClearScreen(void) {
    HAL_LCD_Clear();
}

void DRV_LCD_DisplayPowerMode(const char *mode) {
    HAL_LCD_SetCursor(0, 0);
    HAL_LCD_WriteString("Mode: ");
    HAL_LCD_WriteString(mode);
}

void DRV_LCD_DisplayVoltage(float vSet, float vOut, float vIn) {
    char buffer[30];
    HAL_LCD_SetCursor(1, 0);
    sprintf(buffer, "Vset:%.2fV Vout:%.2fV", vSet, vOut);
    HAL_LCD_WriteString(buffer);
    HAL_LCD_SetCursor(2, 0);
    sprintf(buffer, "Vin: %.2fV", vIn);
    HAL_LCD_WriteString(buffer);
}

void DRV_LCD_DisplayCurrent(float iOut) {
    char buffer[20];
    HAL_LCD_SetCursor(3, 0);
    sprintf(buffer, "Iout: %.3fA", iOut);
    HAL_LCD_WriteString(buffer);
}

void DRV_LCD_DisplayPower(float pOut) {
    char buffer[20];
    HAL_LCD_SetCursor(3, 12); // Example positioning
    sprintf(buffer, "Pout: %.2fW", pOut);
    HAL_LCD_WriteString(buffer);
}

void DRV_LCD_DisplayEfficiency(float efficiency) {
    char buffer[20];
    HAL_LCD_SetCursor(4, 0);
    sprintf(buffer, "Eff: %.1f%%", efficiency * 100.0f);
    HAL_LCD_WriteString(buffer);
}


// drv_button.h
#ifndef DRV_BUTTON_H
#define DRV_BUTTON_H

typedef enum {
    BUTTON_MENU,
    BUTTON_UP,
    BUTTON_DOWN,
    BUTTON_OK,
    BUTTON_START,
    BUTTON_RST,
    BUTTON_MAX
} ButtonTypeDef;

typedef enum {
    BUTTON_STATE_RELEASED,
    BUTTON_STATE_PRESSED,
    BUTTON_STATE_LONG_PRESSED
} ButtonStateTypeDef;

void DRV_Button_Init(void);
ButtonStateTypeDef DRV_Button_GetState(ButtonTypeDef button);

#endif // DRV_BUTTON_H

// drv_button.c (简略示例 - 轮询方式)
#include "drv_button.h"
#include "hal_gpio.h"
#include "hal_timer.h"

#define BUTTON_DEBOUNCE_DELAY_MS 50
#define BUTTON_LONG_PRESS_DELAY_MS 1000

// Define GPIO pins for buttons (example - adjust to your hardware)
#define BUTTON_MENU_PIN   GPIO_PIN_0
#define BUTTON_UP_PIN     GPIO_PIN_1
#define BUTTON_DOWN_PIN   GPIO_PIN_2
#define BUTTON_OK_PIN     GPIO_PIN_3
#define BUTTON_START_PIN  GPIO_PIN_4
#define BUTTON_RST_PIN    GPIO_PIN_5

void DRV_Button_Init(void) {
    // Initialize button pins as input with pull-up resistors (example)
    HAL_GPIO_Init(BUTTON_MENU_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
    HAL_GPIO_Init(BUTTON_UP_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
    HAL_GPIO_Init(BUTTON_DOWN_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
    HAL_GPIO_Init(BUTTON_OK_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
    HAL_GPIO_Init(BUTTON_START_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
    HAL_GPIO_Init(BUTTON_RST_PIN, GPIO_MODE_INPUT, GPIO_SPEED_LOW, GPIO_PULL_UP);
}

ButtonStateTypeDef DRV_Button_GetState(ButtonTypeDef button) {
    GPIO_PinTypeDef buttonPin;
    switch (button) {
        case BUTTON_MENU:    buttonPin = BUTTON_MENU_PIN;    break;
        case BUTTON_UP:      buttonPin = BUTTON_UP_PIN;      break;
        case BUTTON_DOWN:    buttonPin = BUTTON_DOWN_PIN;    break;
        case BUTTON_OK:      buttonPin = BUTTON_OK_PIN;      break;
        case BUTTON_START:   buttonPin = BUTTON_START_PIN;   break;
        case BUTTON_RST:     buttonPin = BUTTON_RST_PIN;     break;
        default: return BUTTON_STATE_RELEASED;
    }

    static uint8_t buttonState[BUTTON_MAX] = {0}; // 0: Released, 1: Pressed
    static uint32_t lastPressTime[BUTTON_MAX] = {0};

    uint8_t rawState = !HAL_GPIO_ReadPin(buttonPin); // Assuming button is active low

    if (rawState) { // Button is physically pressed
        if (!buttonState[button]) { // Button was previously released
            HAL_Delay_ms(BUTTON_DEBOUNCE_DELAY_MS); // Debounce delay
            if (!HAL_GPIO_ReadPin(buttonPin)) { // Still pressed after debounce
                buttonState[button] = 1;
                lastPressTime[button] = HAL_GetTick_ms(); // Record press time (assuming HAL_GetTick_ms() exists)
                return BUTTON_STATE_PRESSED;
            }
        } else { // Button is already considered pressed
            if ((HAL_GetTick_ms() - lastPressTime[button]) > BUTTON_LONG_PRESS_DELAY_MS) {
                return BUTTON_STATE_LONG_PRESSED;
            }
        }
    } else { // Button is physically released
        buttonState[button] = 0;
        return BUTTON_STATE_RELEASED;
    }

    return BUTTON_STATE_RELEASED; // Default return if no state change detected
}

3. BOOST 控制层代码示例 (boost_control.h, boost_control.c):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
// boost_control.h
#ifndef BOOST_CONTROL_H
#define BOOST_CONTROL_H

#include "drv_adc.h"
#include "drv_pwm.h"

#define BOOST_CONTROL_PERIOD_MS 10 // Control loop period in milliseconds

typedef enum {
    BOOST_MODE_CV,       // Constant Voltage Mode
    BOOST_MODE_CC,       // Constant Current Mode
    // ... more modes if needed
    BOOST_MODE_MAX
} BoostModeTypeDef;

typedef struct {
    float targetVoltage;
    float targetCurrent;
    BoostModeTypeDef mode;
    // ... more control parameters
} BoostControlConfigTypeDef;

void BOOST_CTRL_Init(void);
void BOOST_CTRL_SetMode(BoostModeTypeDef mode);
void BOOST_CTRL_SetTargetVoltage(float voltage);
void BOOST_CTRL_SetTargetCurrent(float current);
void BOOST_CTRL_ControlLoop(void); // Call periodically to execute control logic
BoostControlConfigTypeDef BOOST_CTRL_GetConfig(void);

#endif // BOOST_CONTROL_H

// boost_control.c
#include "boost_control.h"
#include "drv_adc.h"
#include "drv_pwm.h"
#include "hal_timer.h"

// PID controller parameters (example - needs tuning)
#define KP 0.1f
#define KI 0.01f
#define KD 0.001f

static BoostControlConfigTypeDef boostConfig;
static BoostModeTypeDef currentMode = BOOST_MODE_CV;
static float integralError = 0.0f;
static float lastError = 0.0f;

void BOOST_CTRL_Init(void) {
    boostConfig.targetVoltage = 5.0f; // Default target voltage
    boostConfig.targetCurrent = 1.0f; // Default target current
    boostConfig.mode = BOOST_MODE_CV;
    currentMode = BOOST_MODE_CV;
}

BoostControlConfigTypeDef BOOST_CTRL_GetConfig(void) {
    return boostConfig;
}

void BOOST_CTRL_SetMode(BoostModeTypeDef mode) {
    currentMode = mode;
    boostConfig.mode = mode;
}

void BOOST_CTRL_SetTargetVoltage(float voltage) {
    boostConfig.targetVoltage = voltage;
}

void BOOST_CTRL_SetTargetCurrent(float current) {
    boostConfig.targetCurrent = current;
}


void BOOST_CTRL_ControlLoop(void) {
    float measuredVoltage = DRV_ADC_ReadVoltage(ADC_CHANNEL_0); // Assuming ADC channel 0 for voltage feedback
    float measuredCurrent = DRV_ADC_ReadCurrent(ADC_CHANNEL_1); // Assuming ADC channel 1 for current feedback
    float error;

    if (currentMode == BOOST_MODE_CV) {
        error = boostConfig.targetVoltage - measuredVoltage;
    } else if (currentMode == BOOST_MODE_CC) {
        error = boostConfig.targetCurrent - measuredCurrent;
    } else {
        error = 0.0f; // Default error if mode is unknown
    }


    integralError += error * BOOST_CONTROL_PERIOD_MS / 1000.0f; // Integrate error
    float derivativeError = (error - lastError) / (BOOST_CONTROL_PERIOD_MS / 1000.0f); // Differentiate error

    float outputPWM = KP * error + KI * integralError + KD * derivativeError;

    // Clamp PWM duty cycle to be within valid range (0.0 to 1.0)
    if (outputPWM < 0.0f) outputPWM = 0.0f;
    if (outputPWM > 0.95f) outputPWM = 0.95f;

    DRV_PWM_SetBoostDutyCycle(outputPWM);

    lastError = error;
}

4. 电源管理层代码示例 (power_management.h, power_management.c):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
// power_management.h
#ifndef POWER_MANAGEMENT_H
#define POWER_MANAGEMENT_H

#include "boost_control.h"

typedef enum {
    POWER_STATE_NORMAL,
    POWER_STATE_OVER_VOLTAGE,
    POWER_STATE_OVER_CURRENT,
    POWER_STATE_OVER_TEMPERATURE,
    POWER_STATE_UNDER_VOLTAGE_INPUT,
    POWER_STATE_FAULT,
    POWER_STATE_STANDBY,
    POWER_STATE_MAX
} PowerStateTypeDef;

void POWER_MGMT_Init(void);
void POWER_MGMT_SetPowerMode(BoostModeTypeDef mode);
void POWER_MGMT_SetTargetVoltage(float voltage);
void POWER_MGMT_SetTargetCurrent(float current);
PowerStateTypeDef POWER_MGMT_GetPowerState(void);
void POWER_MGMT_CheckProtections(void); // Check for over-voltage, over-current etc.
void POWER_MGMT_EnterStandby(void);
void POWER_MGMT_ExitStandby(void);

#endif // POWER_MANAGEMENT_H

// power_management.c
#include "power_management.h"
#include "boost_control.h"
#include "drv_adc.h"
#include "drv_lcd.h"
#include "hal_timer.h"

#define OVER_VOLTAGE_THRESHOLD  13.0f // Example: 13V over-voltage threshold
#define OVER_CURRENT_THRESHOLD  1.2f  // Example: 1.2A over-current threshold
#define OVER_TEMPERATURE_THRESHOLD 80.0f // Example: 80 degrees Celsius
#define UNDER_VOLTAGE_INPUT_THRESHOLD 2.8f // Example: 2.8V input under-voltage


static PowerStateTypeDef currentPowerState = POWER_STATE_NORMAL;
static BoostModeTypeDef currentPowerMode = BOOST_MODE_CV;


void POWER_MGMT_Init(void) {
    currentPowerState = POWER_STATE_NORMAL;
    currentPowerMode = BOOST_MODE_CV;
    BOOST_CTRL_Init();
    BOOST_CTRL_SetMode(currentPowerMode);
    BOOST_CTRL_SetTargetVoltage(BOOST_CTRL_GetConfig().targetVoltage);
    BOOST_CTRL_SetTargetCurrent(BOOST_CTRL_GetConfig().targetCurrent);
}

PowerStateTypeDef POWER_MGMT_GetPowerState(void) {
    return currentPowerState;
}

void POWER_MGMT_SetPowerMode(BoostModeTypeDef mode) {
    currentPowerMode = mode;
    BOOST_CTRL_SetMode(mode);
}

void POWER_MGMT_SetTargetVoltage(float voltage) {
    BOOST_CTRL_SetTargetVoltage(voltage);
}

void POWER_MGMT_SetTargetCurrent(float current) {
    BOOST_CTRL_SetTargetCurrent(current);
}


void POWER_MGMT_CheckProtections(void) {
    float measuredVoltage = DRV_ADC_ReadVoltage(ADC_CHANNEL_0);
    float measuredCurrent = DRV_ADC_ReadCurrent(ADC_CHANNEL_1);
    float inputVoltage = DRV_ADC_ReadVoltage(ADC_CHANNEL_2); // Assume ADC channel 2 for input voltage
    // ... Read temperature sensor if available

    if (measuredVoltage > OVER_VOLTAGE_THRESHOLD) {
        currentPowerState = POWER_STATE_OVER_VOLTAGE;
        // ... Implement OVP handling - e.g., turn off PWM, display error message
        DRV_PWM_SetBoostDutyCycle(0.0f); // Turn off BOOST
        DRV_LCD_ClearScreen();
        DRV_LCD_WriteString("OVP! Shutdown");
    } else if (measuredCurrent > OVER_CURRENT_THRESHOLD) {
        currentPowerState = POWER_STATE_OVER_CURRENT;
        // ... Implement OCP handling
        DRV_PWM_SetBoostDutyCycle(0.0f); // Turn off BOOST
        DRV_LCD_ClearScreen();
        DRV_LCD_WriteString("OCP! Shutdown");
    } else if (inputVoltage < UNDER_VOLTAGE_INPUT_THRESHOLD) {
        currentPowerState = POWER_STATE_UNDER_VOLTAGE_INPUT;
        // ... Implement UVP handling
        DRV_PWM_SetBoostDutyCycle(0.0f); // Turn off BOOST
        DRV_LCD_ClearScreen();
        DRV_LCD_WriteString("UVP Input! Shutdown");
    }
    // ... Check for OTP if temperature sensor is available
    else {
        currentPowerState = POWER_STATE_NORMAL; // Back to normal if no fault
    }
}

void POWER_MGMT_EnterStandby(void) {
    currentPowerState = POWER_STATE_STANDBY;
    DRV_PWM_SetBoostDutyCycle(0.0f); // Turn off BOOST in standby
    // ... Power down other peripherals if needed
    DRV_LCD_ClearScreen();
    DRV_LCD_WriteString("Standby Mode");
}

void POWER_MGMT_ExitStandby(void) {
    currentPowerState = POWER_STATE_NORMAL;
    // ... Re-initialize peripherals if needed
    DRV_LCD_ClearScreen();
    DRV_LCD_WriteString("Normal Mode");
    // ... Resume normal operation
}

5. 应用层代码示例 (main.c):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
#include "hal_timer.h" // Assuming a HAL_GetTick_ms() function for timing
#include "drv_adc.h"
#include "drv_pwm.h"
#include "drv_lcd.h"
#include "drv_button.h"
#include "boost_control.h"
#include "power_management.h"

#define DISPLAY_UPDATE_PERIOD_MS 500
#define CONTROL_LOOP_PERIOD_MS   BOOST_CONTROL_PERIOD_MS // Defined in boost_control.h
#define PROTECTION_CHECK_PERIOD_MS 100

int main(void) {
    // System Initialization
    DRV_ADC_Init();
    DRV_PWM_Init();
    DRV_LCD_Init();
    DRV_Button_Init();
    POWER_MGMT_Init();


    uint32_t lastDisplayUpdateTime = HAL_GetTick_ms();
    uint32_t lastControlLoopTime = HAL_GetTick_ms();
    uint32_t lastProtectionCheckTime = HAL_GetTick_ms();


    while (1) {
        // Button Input Handling
        if (DRV_Button_GetState(BUTTON_MENU) == BUTTON_STATE_PRESSED) {
            // ... Handle MENU button press - e.g., enter menu, switch modes
            POWER_MGMT_SetPowerMode((POWER_MGMT_GetPowerState() == BOOST_MODE_CV) ? BOOST_MODE_CC : BOOST_MODE_CV); // Toggle mode CV/CC
            DRV_LCD_ClearScreen(); // Clear display to update mode
        }
        if (DRV_Button_GetState(BUTTON_UP) == BUTTON_STATE_PRESSED) {
            // ... Handle UP button press - e.g., increase target voltage/current
            if (POWER_MGMT_GetPowerState() == BOOST_MODE_CV) {
                POWER_MGMT_SetTargetVoltage(BOOST_CTRL_GetConfig().targetVoltage + 0.1f); // Increase by 0.1V
            } else if (POWER_MGMT_GetPowerState() == BOOST_MODE_CC) {
                POWER_MGMT_SetTargetCurrent(BOOST_CTRL_GetConfig().targetCurrent + 0.01f); // Increase by 0.01A
            }
        }
        if (DRV_Button_GetState(BUTTON_DOWN) == BUTTON_STATE_PRESSED) {
            // ... Handle DOWN button press - e.g., decrease target voltage/current
            if (POWER_MGMT_GetPowerState() == BOOST_MODE_CV) {
                POWER_MGMT_SetTargetVoltage(BOOST_CTRL_GetConfig().targetVoltage - 0.1f); // Decrease by 0.1V
            } else if (POWER_MGMT_GetPowerState() == BOOST_MODE_CC) {
                POWER_MGMT_SetTargetCurrent(BOOST_CTRL_GetConfig().targetCurrent - 0.01f); // Decrease by 0.01A
            }
        }
        if (DRV_Button_GetState(BUTTON_OK) == BUTTON_STATE_PRESSED) {
            // ... Handle OK button press - e.g., confirm selection in menu
        }
        if (DRV_Button_GetState(BUTTON_START) == BUTTON_STATE_PRESSED) {
            // ... Handle START button press - e.g., start/stop BOOST operation, enter/exit standby
            if (POWER_MGMT_GetPowerState() == POWER_STATE_STANDBY) {
                POWER_MGMT_ExitStandby();
            } else {
                POWER_MGMT_EnterStandby();
            }
        }
        if (DRV_Button_GetState(BUTTON_RST) == BUTTON_STATE_PRESSED) {
            // ... Handle RESET button press - e.g., system reset
            // ... Software reset or hardware reset
            // ... Example: NVIC_SystemReset(); (if using ARM Cortex-M)
        }


        // Control Loop Execution (Periodic)
        if ((HAL_GetTick_ms() - lastControlLoopTime) >= CONTROL_LOOP_PERIOD_MS) {
            lastControlLoopTime = HAL_GetTick_ms();
            BOOST_CTRL_ControlLoop();
        }

        // Protection Checks (Periodic)
        if ((HAL_GetTick_ms() - lastProtectionCheckTime) >= PROTECTION_CHECK_PERIOD_MS) {
            lastProtectionCheckTime = HAL_GetTick_ms();
            POWER_MGMT_CheckProtections();
        }


        // Display Update (Periodic)
        if ((HAL_GetTick_ms() - lastDisplayUpdateTime) >= DISPLAY_UPDATE_PERIOD_MS) {
            lastDisplayUpdateTime = HAL_GetTick_ms();
            float vIn = DRV_ADC_ReadVoltage(ADC_CHANNEL_2); // Assume ADC channel 2 for input voltage
            float vOut = DRV_ADC_ReadVoltage(ADC_CHANNEL_0);
            float iOut = DRV_ADC_ReadCurrent(ADC_CHANNEL_1);
            float pOut = vOut * iOut;
            float efficiency = 0.0f; // Calculate efficiency if input current is measured as well

            DRV_LCD_ClearScreen();
            DRV_LCD_DisplayPowerMode((POWER_MGMT_GetPowerState() == BOOST_MODE_CV) ? "CV" : "CC");
            DRV_LCD_DisplayVoltage(BOOST_CTRL_GetConfig().targetVoltage, vOut, vIn);
            DRV_LCD_DisplayCurrent(iOut);
            DRV_LCD_DisplayPower(pOut);
            DRV_LCD_DisplayEfficiency(efficiency);
            // ... Display other parameters and power state if needed
        }

        // ... Other application logic, background tasks, etc.

        HAL_Delay_ms(1); // Small delay to reduce CPU usage if needed
    }
}

// ---  HAL_GetTick_ms() implementation example (if not provided by HAL) ---
// (This is a very basic software timer example, for real-time accuracy, use a hardware timer)
static volatile uint32_t sysTickCounter = 0;

void SysTick_Handler(void) { // Example SysTick interrupt handler
    sysTickCounter++;
}

uint32_t HAL_GetTick_ms(void) {
    return sysTickCounter;
}

// ---  Initialize SysTick timer (example) ---
void HAL_InitTick(uint32_t tickFrequency_Hz) {
  SysTick_Config(SystemCoreClock / tickFrequency_Hz); // Assuming SystemCoreClock is defined
}

项目开发流程

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

  1. 需求分析: 明确项目目标、功能需求、性能指标、约束条件等，形成详细的需求文档。 (本项目已在前面详细描述)

  2. 系统设计: 根据需求文档，进行系统架构设计、硬件选型、软件架构设计、模块划分、接口定义等，形成系统设计文档。 (本项目架构设计已在前面详细描述)

  3. 硬件设计与制作: 设计 BOOST 电路原理图、PCB Layout，选择合适的元器件，制作 PCB 板，并进行硬件调试。

  4. 软件开发: 根据软件架构设计，进行各模块的代码编写、单元测试、集成测试、系统测试等。 (本项目已提供关键模块的 C 代码示例)

  5. 系统集成与测试: 将硬件和软件进行集成，进行全面的系统功能测试、性能测试、可靠性测试、稳定性测试、兼容性测试等，并进行问题定位和修复。

  6. 验证与确认: 验证系统是否满足所有需求，确认系统是否符合设计目标。

  7. 维护与升级: 在系统部署后，进行日常维护、故障排除、软件升级、功能扩展等。

总结

本方案详细介绍了数字 BOOST 电路智能控制与显示系统的设计架构和关键 C 代码实现。我们采用了分层架构和模块化设计思想，结合数字 PID 控制、PWM 技术、ADC 采样、LCD 显示、按键输入等关键技术，力求打造一个可靠、高效、可扩展的嵌入式系统平台。提供的 C 代码示例涵盖了 HAL 层、设备驱动层、BOOST 控制层、电源管理层和应用层的主要模块，可以作为项目开发的参考。

后续工作与改进方向

  • 硬件电路设计: 需要根据具体的应用场景和性能指标，进行详细的 BOOST 电路硬件设计，包括功率器件选型、电感电容参数计算、保护电路设计等。
  • PID 参数整定: 需要根据实际硬件电路，进行 PID 控制参数的整定，以获得最佳的控制性能和稳定性。可以使用实验法、经验法或自动整定算法进行参数整定。
  • 效率优化: 可以进一步优化 BOOST 电路的设计和控制算法，例如采用同步整流技术、软开关技术、自适应 PWM 频率调整等，以提高能量转换效率。
  • 用户界面优化: 可以设计更友好的用户界面，例如使用图形化界面、菜单导航、参数设置界面等，提高用户体验。
  • 功能扩展: 可以根据实际需求进行功能扩展，例如增加数据记录功能 (记录电压、电流、功率等数据)、远程监控功能 (通过通信接口将数据上传到上位机或云平台)、更高级的保护功能 (例如短路保护、过功率保护等)。
  • 代码优化与移植性: 可以进一步优化 C 代码，提高代码的执行效率和可读性。同时，提高代码的移植性，使其可以方便地移植到不同的 MCU 平台。

希望这份详细的方案和代码示例能够帮助您理解和实现数字 BOOST 电路的嵌入式系统项目。在实际开发过程中，还需要根据具体的硬件平台、需求细节和测试结果进行调整和优化。

欢迎关注我的其它发布渠道