简介：超迷你的加热台，PD20V供电，加热面大小5.6*5.6cm，可以通过两个按键设置参数。

好的，作为一名高级嵌入式软件开发工程师，我将为您详细介绍这个迷你加热台嵌入式系统的代码设计架构，并提供一个符合实际应用且可扩展的C代码实现方案。
关注微信公众号，提前获取相关推文

项目概览与需求分析

首先，我们来明确这个超迷你加热台的需求：

核心功能: 加热金属平台至用户设定的温度。
控制方式: 通过两个按键进行参数设置。
供电: PD 20V供电。
显示: 显示当前温度、设定温度、状态等信息（根据图片推测为小型OLED/LCD）。
加热面尺寸: 5.6cm * 5.6cm，相对较小，需要精确控温。
目标: 可靠、高效、可扩展的系统平台。

基于以上需求，我们可以进行更细致的需求分析：

温度控制精度和范围: 需要确定加热台的温度控制范围（例如室温到300℃？）以及需要的精度（例如 ±1℃？）。这将直接影响温度传感器的选择和PID控制器的设计。
用户交互: 两个按键的操作逻辑需要明确，例如：
- 一个按键用于模式切换（设置/运行）。
- 一个按键用于数值调整（增加/减少）。
- 或者组合按键实现更多功能（例如长按进入菜单）。
显示内容: 需要显示哪些信息？例如：
- 当前温度
- 设定温度
- 运行状态（加热中、停止、错误等）
- 其他可选信息（例如倒计时、功率百分比等）
安全特性: 考虑到加热设备的安全，需要加入过温保护功能。
可扩展性: 系统设计要考虑未来的扩展需求，例如：
- 增加更多控制参数（例如PID参数手动调节）。
- 增加通信接口（例如USB、串口，用于上位机控制或固件升级）。
- 增加更复杂的加热模式（例如程序升温曲线）。

代码设计架构

为了构建一个可靠、高效、可扩展的嵌入式系统，我推荐采用分层架构的设计方法。分层架构将系统分解为多个独立的层次，每一层专注于特定的功能，层与层之间通过清晰的接口进行交互。这种架构具有以下优点：

模块化: 每个层次和模块职责明确，易于理解、开发和维护。
可重用性: 底层模块（例如HAL、驱动）可以被其他项目复用。
可扩展性: 增加新功能或修改现有功能时，影响范围局限在特定层次和模块内。
易于测试: 可以对每个模块进行单元测试，提高代码质量。

针对这个迷你加热台项目，我建议采用以下分层架构：

+---------------------+
|    Application Layer    |  (应用层) - 用户界面、状态机、应用逻辑
+---------------------+
         |
+---------------------+
|   System Services   |  (系统服务层) - 温度控制、UI管理、参数管理、安全监控
+---------------------+
         |
+---------------------+
|  Device Drivers     |  (设备驱动层) - 温度传感器驱动、加热器驱动、显示驱动、按键驱动
+---------------------+
         |
+---------------------+
| Hardware Abstraction|  (硬件抽象层 - HAL) -  GPIO、ADC、PWM、Timer等底层硬件接口
+---------------------+
         |
+---------------------+
|      Hardware       |  (硬件层) - MCU、温度传感器、加热器、显示屏、按键
+---------------------+

各层的功能职责：

硬件层 (Hardware Layer): 实际的硬件组件，包括微控制器 (MCU)、温度传感器、加热元件、显示屏、按键等。
硬件抽象层 (HAL - Hardware Abstraction Layer): 直接与硬件交互的底层软件层。它提供了一组通用的API，用于访问MCU的各种硬件资源，例如：
- GPIO (General Purpose Input/Output): 控制数字IO，例如按键输入、加热器控制信号输出。
- ADC (Analog-to-Digital Converter): 读取模拟信号，例如温度传感器输出的电压信号。
- PWM (Pulse Width Modulation): 生成脉冲宽度调制信号，用于控制加热器的功率。
- Timer: 提供定时功能，用于系统时钟、定时任务、PWM信号生成等。
- SPI/I2C/UART: 串行通信接口，用于与外围设备通信，例如显示屏、外部传感器等。
HAL层的目标是屏蔽底层硬件的差异，为上层提供统一的硬件访问接口。这样，当更换MCU或硬件平台时，只需要修改HAL层代码，而上层代码无需改动。
设备驱动层 (Device Drivers): 构建在HAL层之上，负责驱动具体的硬件设备。例如：
- 温度传感器驱动: 负责初始化温度传感器、读取原始传感器数据、将原始数据转换为温度值（例如摄氏度）。
- 加热器驱动: 负责控制加热器的开关和功率调节（例如通过PWM控制）。
- 显示驱动: 负责初始化显示屏、在屏幕上显示文本、数字、图形等信息。
- 按键驱动: 负责检测按键按下事件、进行按键去抖动处理、识别按键长按和短按等操作。
设备驱动层提供设备特定的功能接口，例如 TemperatureSensor_ReadTemperature()、Heater_SetPower()、Display_WriteString()、Button_IsPressed() 等。
系统服务层 (System Services): 构建在设备驱动层之上，提供一些通用的系统服务功能，用于支撑应用层。例如：
- 温度控制模块 (Temperature Control): 实现PID控制算法，根据设定的温度和当前温度，自动调节加热器功率，使温度稳定在目标值。
- 用户界面管理模块 (UI Manager): 管理用户界面的显示逻辑、处理按键输入、更新显示内容、管理系统状态。
- 参数管理模块 (Settings Manager): 负责存储和读取用户设置的参数（例如设定温度），可以使用Flash或EEPROM存储。
- 安全监控模块 (Safety Monitor): 监控系统状态，例如温度是否过高、电压是否异常等，并在出现异常时采取保护措施（例如关闭加热）。
系统服务层提供业务逻辑相关的接口，例如 TemperatureControl_SetTargetTemperature()、UIManager_DisplayTemperature()、SettingsManager_SaveSetting()、SafetyMonitor_CheckTemperature() 等。
应用层 (Application Layer): 位于最顶层，负责实现具体的应用逻辑和用户交互。对于这个迷你加热台项目，应用层主要负责：
- 状态机管理: 定义加热台的各种状态（例如待机、设置温度、加热中、恒温、停止、错误等），并根据用户操作和系统状态进行状态切换。
- 用户交互逻辑: 处理按键输入，根据按键操作进入不同的设置界面或执行不同的功能。
- 温度显示和控制: 从系统服务层获取当前温度，显示在屏幕上，并将用户设定的温度传递给温度控制模块。
- 错误处理和提示: 处理系统服务层报告的错误，并在屏幕上显示错误信息。
应用层通过调用系统服务层的接口来实现具体的功能。

C 代码实现 (详细模块划分与代码示例)

为了满足您对代码量的要求，并提供一个相对完整的示例，我将详细展开每个层次和模块的代码实现。请注意，以下代码示例为了演示架构和关键逻辑，可能省略了一些错误处理、边界条件检查、以及硬件平台相关的初始化配置代码。实际项目中，您需要根据具体的硬件平台和需求进行完善。

1. Hardware Abstraction Layer (HAL)

我们假设使用一个常见的STM32系列MCU作为控制核心。 HAL层的文件通常放在 hal/ 目录下。

hal/hal_gpio.h

#ifndef HAL_GPIO_H
#define HAL_GPIO_H

// 定义GPIO端口和引脚
typedef enum {
    GPIO_PORT_A,
    GPIO_PORT_B,
    // ... 其他端口
    GPIO_PORT_MAX
} GPIO_Port_TypeDef;

typedef enum {
    GPIO_PIN_0,
    GPIO_PIN_1,
    // ... 其他引脚
    GPIO_PIN_MAX
} GPIO_Pin_TypeDef;

// 定义GPIO模式
typedef enum {
    GPIO_MODE_INPUT,
    GPIO_MODE_OUTPUT,
    GPIO_MODE_OUTPUT_OD, // 开漏输出
    // ... 其他模式
} GPIO_Mode_TypeDef;

// 定义GPIO输出类型
typedef enum {
    GPIO_OUTPUT_PP, // 推挽输出
    GPIO_OUTPUT_OD  // 开漏输出
} GPIO_OutputType_TypeDef;

// 定义GPIO上拉/下拉
typedef enum {
    GPIO_PULL_NONE,
    GPIO_PULL_UP,
    GPIO_PULL_DOWN
} GPIO_Pull_TypeDef;

// 初始化GPIO引脚
void HAL_GPIO_Init(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin, GPIO_Mode_TypeDef mode, GPIO_OutputType_TypeDef output_type, GPIO_Pull_TypeDef pull);

// 设置GPIO引脚输出高电平
void HAL_GPIO_SetPinHigh(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin);

// 设置GPIO引脚输出低电平
void HAL_GPIO_SetPinLow(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin);

// 读取GPIO引脚输入电平
uint8_t HAL_GPIO_ReadPin(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin);

#endif // HAL_GPIO_H

hal/hal_gpio.c

#include "hal_gpio.h"
// ...  包含具体的MCU头文件，例如 #include "stm32fxxx_hal.h"

void HAL_GPIO_Init(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin, GPIO_Mode_TypeDef mode, GPIO_OutputType_TypeDef output_type, GPIO_Pull_TypeDef pull) {
    // ...  根据 port 和 pin 转换成具体的 MCU 端口和引脚定义 (例如 GPIOA, GPIO_PIN_0)
    // ...  配置 MCU 硬件寄存器，初始化 GPIO 引脚，例如设置模式、输出类型、上下拉
    // ...  (此处为硬件平台相关的代码，需要根据具体的MCU手册编写)

    // 示例 (伪代码，需要根据实际 MCU HAL 库修改)
    // GPIO_InitTypeDef GPIO_InitStruct = {0};
    // GPIO_InitStruct.Pin = (1 << pin); // 假设 GPIO_PIN_x 就是位移量
    // GPIO_InitStruct.Mode = mode;
    // GPIO_InitStruct.Pull = pull;
    // GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW; // 可选
    // GPIO_InitStruct.OutputType = output_type;
    // HAL_GPIO_Init(getPortHandle(port), &GPIO_InitStruct); // getPortHandle 假设能根据 GPIO_Port_TypeDef 返回 GPIOx 外设句柄
}

void HAL_GPIO_SetPinHigh(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin) {
    // ...  根据 port 和 pin 转换成具体的 MCU 端口和引脚定义
    // ...  设置 GPIO 引脚输出高电平 (例如 HAL_GPIO_WritePin(getPortHandle(port), (1 << pin), GPIO_PIN_SET);)
}

void HAL_GPIO_SetPinLow(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin) {
    // ...  根据 port 和 pin 转换成具体的 MCU 端口和引脚定义
    // ...  设置 GPIO 引脚输出低电平 (例如 HAL_GPIO_WritePin(getPortHandle(port), (1 << pin), GPIO_PIN_RESET);)
}

uint8_t HAL_GPIO_ReadPin(GPIO_Port_TypeDef port, GPIO_Pin_TypeDef pin) {
    // ...  根据 port 和 pin 转换成具体的 MCU 端口和引脚定义
    // ...  读取 GPIO 引脚输入电平 (例如 HAL_GPIO_ReadPin(getPortHandle(port), (1 << pin)) == GPIO_PIN_SET ? 1 : 0;)
    return 0; // 示例返回值
}

hal/hal_adc.h

#ifndef HAL_ADC_H
#define HAL_ADC_H

// 定义ADC通道
typedef enum {
    ADC_CHANNEL_0,
    ADC_CHANNEL_1,
    // ... 其他通道
    ADC_CHANNEL_MAX
} ADC_Channel_TypeDef;

// 初始化ADC
void HAL_ADC_Init(ADC_Channel_TypeDef channel);

// 读取ADC通道的原始值
uint16_t HAL_ADC_ReadChannel(ADC_Channel_TypeDef channel);

#endif // HAL_ADC_H

hal/hal_adc.c

#include "hal_adc.h"
// ...  包含具体的MCU头文件

void HAL_ADC_Init(ADC_Channel_TypeDef channel) {
    // ...  根据 channel 转换成具体的 MCU ADC 通道定义 (例如 ADC_CHANNEL_x)
    // ...  初始化 ADC 外设，例如使能时钟、配置分辨率、采样时间、通道选择等
    // ...  (此处为硬件平台相关的代码，需要根据具体的MCU手册编写)

    // 示例 (伪代码)
    // ADC_HandleTypeDef hadc = {0};
    // ADC_ChannelConfTypeDef sConfig = {0};

    // /* Configure the global features of the ADC (ClockPrescaler/Resolution/DataAlignment/ScanConvMode) */
    // hadc.Instance = ADCx; // 假设 ADCx 是根据 channel 确定的 ADC 外设
    // hadc.Init.ClockPrescaler = ADC_CLOCK_SYNC_PCLK_DIV4;
    // hadc.Init.Resolution = ADC_RESOLUTION_12B;
    // hadc.Init.DataAlign = ADC_DATAALIGN_RIGHT;
    // hadc.Init.ScanConvMode = DISABLE;
    // hadc.Init.ContinuousConvMode = DISABLE;
    // hadc.Init.DiscontinuousConvMode = DISABLE;
    // hadc.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
    // hadc.Init.ExternalTrigConv = ADC_SOFTWARE_START;
    // hadc.Init.DMAContinuousRequests = DISABLE;
    // hadc.Init.EOCSelection = ADC_EOC_SINGLE_CONV;
    // HAL_ADC_Init(&hadc);

    // /* Configure for the selected ADC regular channel its corresponding rank in the sequencer and its sample time. */
    // sConfig.Channel = channel; // 假设 ADC_CHANNEL_x 就是 MCU HAL 库定义的通道宏
    // sConfig.Rank = ADC_REGULAR_RANK_1;
    // sConfig.SamplingTime = ADC_SAMPLETIME_28CYCLES;
    // HAL_ADC_ConfigChannel(&hadc, &sConfig);
}

uint16_t HAL_ADC_ReadChannel(ADC_Channel_TypeDef channel) {
    // ...  根据 channel 转换成具体的 MCU ADC 通道定义
    // ...  启动 ADC 转换
    // ...  等待转换完成
    // ...  读取 ADC 数据寄存器
    // ...  返回 ADC 原始值

    // 示例 (伪代码)
    // HAL_ADC_Start(&hadc);
    // HAL_ADC_PollForConversion(&hadc, 100); // 超时时间 100ms
    // return HAL_ADC_GetValue(&hadc);
    return 0; // 示例返回值
}

hal/hal_timer.h

#ifndef HAL_TIMER_H
#define HAL_TIMER_H

// 定义定时器外设
typedef enum {
    TIMER_1,
    TIMER_2,
    // ... 其他定时器
    TIMER_MAX
} TIMER_TypeDef;

// 初始化定时器 (通用定时器)
void HAL_Timer_Base_Init(TIMER_TypeDef timer, uint32_t prescaler, uint32_t period);

// 启动定时器
void HAL_Timer_Start(TIMER_TypeDef timer);

// 停止定时器
void HAL_Timer_Stop(TIMER_TypeDef timer);

// 初始化PWM输出 (定时器通道)
void HAL_Timer_PWM_Init(TIMER_TypeDef timer, uint32_t channel, uint32_t prescaler, uint32_t period);

// 设置PWM占空比 (0 - 1000, 对应 0% - 100%)
void HAL_Timer_PWM_SetDutyCycle(TIMER_TypeDef timer, uint32_t channel, uint32_t duty_cycle);

#endif // HAL_TIMER_H

hal/hal_timer.c

#include "hal_timer.h"
// ... 包含具体的MCU头文件

void HAL_Timer_Base_Init(TIMER_TypeDef timer, uint32_t prescaler, uint32_t period) {
    // ... 根据 timer 转换成具体的 MCU 定时器外设 (例如 TIMx)
    // ... 初始化定时器基本参数，例如预分频器、计数周期
    // ... (此处为硬件平台相关的代码)

    // 示例 (伪代码)
    // TIM_HandleTypeDef htim = {0};
    // htim.Instance = getTimerInstance(timer); // 假设 getTimerInstance 能根据 TIMER_TypeDef 返回 TIMx 外设句柄
    // htim.Init.Prescaler = prescaler;
    // htim.Init.CounterMode = TIM_COUNTERMODE_UP;
    // htim.Init.Period = period;
    // htim.Init.ClockDivision = TIM_CLOCKDIVISION_DIV1;
    // htim.Init.RepetitionCounter = 0;
    // htim.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_DISABLE;
    // HAL_TIM_Base_Init(&htim);
}

void HAL_Timer_Start(TIMER_TypeDef timer) {
    // ... 根据 timer 转换成具体的 MCU 定时器外设
    // ... 启动定时器 (例如 HAL_TIM_Base_Start(&htim);)
}

void HAL_Timer_Stop(TIMER_TypeDef timer) {
    // ... 根据 timer 转换成具体的 MCU 定时器外设
    // ... 停止定时器 (例如 HAL_TIM_Base_Stop(&htim);)
}

void HAL_Timer_PWM_Init(TIMER_TypeDef timer, uint32_t channel, uint32_t prescaler, uint32_t period) {
    // ... 根据 timer 和 channel 转换成具体的 MCU 定时器外设和通道 (例如 TIMx, TIM_CHANNEL_x)
    // ... 初始化定时器基本参数 (与 HAL_Timer_Base_Init 类似)
    // ... 初始化 PWM 输出配置，例如模式、极性
    // ... (此处为硬件平台相关的代码)

    // 示例 (伪代码)
    // TIM_HandleTypeDef htim = {0};
    // TIM_OC_InitTypeDef sConfigOC = {0};

    // htim.Instance = getTimerInstance(timer);
    // // ... 初始化 htim (与 HAL_Timer_Base_Init 类似)
    // HAL_TIM_Base_Init(&htim);

    // sConfigOC.OCMode = TIM_OCMODE_PWM1;
    // sConfigOC.Pulse = 0; // 初始占空比为 0
    // sConfigOC.OCPolarity = TIM_OCPOLARITY_HIGH;
    // sConfigOC.OCFastMode = TIM_OCFAST_DISABLE;
    // HAL_TIM_PWM_ConfigChannel(&htim, &sConfigOC, getTimerChannel(channel)); // getTimerChannel 假设能根据 channel 返回 TIM_CHANNEL_x
    // HAL_TIM_PWM_Start(&htim, getTimerChannel(channel));
}

void HAL_Timer_PWM_SetDutyCycle(TIMER_TypeDef timer, uint32_t channel, uint32_t duty_cycle) {
    // ... 根据 timer 和 channel 转换成具体的 MCU 定时器外设和通道
    // ... 设置 PWM 占空比 (例如 __HAL_TIM_SET_COMPARE(&htim, getTimerChannel(channel), pulse_value);  pulse_value 根据 duty_cycle 和 period 计算)

    // 示例 (伪代码)
    // uint32_t pulse_value = (duty_cycle * period) / 1000; // 将 0-1000 范围的占空比转换为脉冲值
    // __HAL_TIM_SET_COMPARE(&htim, getTimerChannel(channel), pulse_value);
}

2. Device Drivers (设备驱动层)

设备驱动层的文件通常放在 drivers/ 目录下。

drivers/temp_sensor.h

#ifndef TEMP_SENSOR_H
#define TEMP_SENSOR_H

#include <stdint.h>

// 初始化温度传感器
void TempSensor_Init(void);

// 读取温度 (单位：摄氏度，例如 25.5)
float TempSensor_ReadTemperature(void);

#endif // TEMP_SENSOR_H

drivers/temp_sensor.c

#include "temp_sensor.h"
#include "hal_adc.h"
// ...  包含具体的温度传感器驱动头文件，例如如果使用 PT100 热电阻，可能需要包含 PT100 线性化表格数据

#define TEMP_SENSOR_ADC_CHANNEL ADC_CHANNEL_0 // 假设温度传感器连接到 ADC 通道 0

void TempSensor_Init(void) {
    HAL_ADC_Init(TEMP_SENSOR_ADC_CHANNEL);
    // ...  温度传感器芯片的初始化代码 (例如 I2C 通信初始化、SPI 通信初始化等，如果使用数字传感器)
}

float TempSensor_ReadTemperature(void) {
    uint16_t adc_value = HAL_ADC_ReadChannel(TEMP_SENSOR_ADC_CHANNEL);
    // ...  根据 ADC 值和温度传感器特性，将 ADC 原始值转换为温度值 (摄氏度)
    // ...  例如，如果使用热敏电阻，需要查表或使用公式进行转换
    // ...  如果使用数字温度传感器，则通过 I2C/SPI 读取温度数据

    // 示例 (假设使用线性热敏电阻，ADC 12位，Vref = 3.3V, 热敏电阻分压，查表或线性拟合)
    float voltage = (float)adc_value / 4095.0f * 3.3f; // 将 ADC 值转换为电压
    float temperature = voltage * 20.0f; // 假设线性关系，需要根据实际传感器特性校准
    return temperature;
}

drivers/heater_control.h

#ifndef HEATER_CONTROL_H
#define HEATER_CONTROL_H

#include <stdint.h>

// 初始化加热器控制
void Heater_Init(void);

// 设置加热器功率百分比 (0 - 100)
void Heater_SetPower(uint8_t power_percent);

// 关闭加热器
void Heater_Disable(void);

#endif // HEATER_CONTROL_H

drivers/heater_control.c

#include "heater_control.h"
#include "hal_gpio.h"
#include "hal_timer.h"

#define HEATER_CTRL_GPIO_PORT GPIO_PORT_B
#define HEATER_CTRL_GPIO_PIN  GPIO_PIN_0      // 假设加热器控制信号连接到 PB0
#define HEATER_PWM_TIMER      TIMER_1         // 假设使用 TIMER1 生成 PWM
#define HEATER_PWM_CHANNEL    1               // 假设使用 TIMER1 通道 1

#define HEATER_PWM_PERIOD     1000            // PWM 周期，例如 1kHz (可根据实际情况调整)

void Heater_Init(void) {
    // 使用 GPIO 控制加热器开关 (简单 ON/OFF 控制)
    // HAL_GPIO_Init(HEATER_CTRL_GPIO_PORT, HEATER_CTRL_GPIO_PIN, GPIO_MODE_OUTPUT, GPIO_OUTPUT_PP, GPIO_PULL_NONE);
    // Heater_Disable(); // 初始状态关闭加热器

    // 使用 PWM 控制加热器功率 (更精细的功率调节)
    HAL_Timer_PWM_Init(HEATER_PWM_TIMER, HEATER_PWM_CHANNEL, 100-1, HEATER_PWM_PERIOD - 1); // 预分频器和周期值需要根据 MCU 时钟频率计算，这里假设预分频器为 100，周期为 1000
    Heater_SetPower(0); // 初始状态功率为 0
}

void Heater_SetPower(uint8_t power_percent) {
    if (power_percent > 100) {
        power_percent = 100;
    }
    // 使用 GPIO 控制加热器开关 (ON/OFF)
    // if (power_percent > 0) {
    //     HAL_GPIO_SetPinHigh(HEATER_CTRL_GPIO_PORT, HEATER_CTRL_GPIO_PIN); // 打开加热器
    // } else {
    //     HAL_GPIO_SetPinLow(HEATER_CTRL_GPIO_PORT, HEATER_CTRL_GPIO_PIN);  // 关闭加热器
    // }

    // 使用 PWM 控制加热器功率
    uint32_t duty_cycle = (uint32_t)power_percent * 10; // 将百分比转换为 0-1000 范围的占空比
    HAL_Timer_PWM_SetDutyCycle(HEATER_PWM_TIMER, HEATER_PWM_CHANNEL, duty_cycle);
}

void Heater_Disable(void) {
    Heater_SetPower(0); // 将功率设置为 0 即可关闭加热器
}

drivers/display_driver.h

#ifndef DISPLAY_DRIVER_H
#define DISPLAY_DRIVER_H

#include <stdint.h>

// 初始化显示屏
void Display_Init(void);

// 清屏
void Display_Clear(void);

// 设置光标位置 (行, 列) -  假设显示屏是字符型或简单的点阵屏
void Display_SetCursor(uint8_t row, uint8_t col);

// 显示字符
void Display_WriteChar(char ch);

// 显示字符串
void Display_WriteString(const char *str);

// 显示数字 (整数)
void Display_WriteInteger(int32_t num);

// 显示浮点数 (需要根据实际需求调整精度和格式)
void Display_WriteFloat(float num, uint8_t decimal_places);

#endif // DISPLAY_DRIVER_H

drivers/display_driver.c

#include "display_driver.h"
// ...  包含具体的显示屏驱动库头文件，例如 SPI 或 I2C 通信库，以及显示屏芯片驱动库 (如果使用特定型号的显示屏)
// ...  或者，如果需要自己编写底层驱动，则需要包含 HAL 层 SPI/I2C 相关头文件

void Display_Init(void) {
    // ...  初始化显示屏的硬件接口 (例如 SPI/I2C 初始化)
    // ...  初始化显示屏芯片 (发送初始化命令，例如设置显示模式、清屏等)
    // ... (此处为硬件平台和显示屏型号相关的代码)
}

void Display_Clear(void) {
    // ...  发送清屏命令到显示屏
    // ... (例如发送特定命令字节到 SPI/I2C 接口)
}

void Display_SetCursor(uint8_t row, uint8_t col) {
    // ...  设置显示屏光标位置
    // ... (例如发送设置光标位置的命令字节和行列坐标到 SPI/I2C 接口)
}

void Display_WriteChar(char ch) {
    // ...  发送字符数据到显示屏
    // ... (例如将字符数据字节发送到 SPI/I2C 接口)
}

void Display_WriteString(const char *str) {
    while (*str) {
        Display_WriteChar(*str++);
    }
}

void Display_WriteInteger(int32_t num) {
    char buffer[12]; // 足够存储 32 位整数
    itoa(num, buffer, 10); // 将整数转换为字符串 (需要实现 itoa 函数或使用标准库函数)
    Display_WriteString(buffer);
}

void Display_WriteFloat(float num, uint8_t decimal_places) {
    char buffer[20]; // 足够存储浮点数
    // ...  将浮点数转换为字符串，并控制小数位数 (可以使用 sprintf 或自定义函数)
    // ...  示例 (简单实现，可能精度和格式需要根据实际需求调整)
    sprintf(buffer, "%.*f", decimal_places, num);
    Display_WriteString(buffer);
}

drivers/button_driver.h

#ifndef BUTTON_DRIVER_H
#define BUTTON_DRIVER_H

#include <stdint.h>

// 定义按键ID
typedef enum {
    BUTTON_1,
    BUTTON_2,
    // ... 其他按键
    BUTTON_MAX
} Button_ID_TypeDef;

// 初始化按键
void Button_Init(Button_ID_TypeDef button_id);

// 检测按键是否按下 (返回 1: 按下， 0: 未按下)
uint8_t Button_IsPressed(Button_ID_TypeDef button_id);

// 检测按键是否释放 (返回 1: 释放， 0: 未释放)
uint8_t Button_IsReleased(Button_ID_TypeDef button_id);

// 检测按键是否长按 (需要定时器配合实现)
uint8_t Button_IsLongPressed(Button_ID_TypeDef button_id);

#endif // BUTTON_DRIVER_H

drivers/button_driver.c

#include "button_driver.h"
#include "hal_gpio.h"
// ...  可能需要包含定时器相关的头文件，用于按键长按检测

#define BUTTON1_GPIO_PORT GPIO_PORT_A
#define BUTTON1_GPIO_PIN  GPIO_PIN_1      // 假设 Button 1 连接到 PA1
#define BUTTON2_GPIO_PORT GPIO_PORT_A
#define BUTTON2_GPIO_PIN  GPIO_PIN_2      // 假设 Button 2 连接到 PA2

// ...  可以定义按键去抖动相关的参数 (例如去抖动延时)

void Button_Init(Button_ID_TypeDef button_id) {
    GPIO_Port_TypeDef port;
    GPIO_Pin_TypeDef pin;

    if (button_id == BUTTON_1) {
        port = BUTTON1_GPIO_PORT;
        pin = BUTTON1_GPIO_PIN;
    } else if (button_id == BUTTON_2) {
        port = BUTTON2_GPIO_PORT;
        pin = BUTTON2_GPIO_PIN;
    } else {
        return; //  无效的按键 ID
    }

    HAL_GPIO_Init(port, pin, GPIO_MODE_INPUT, GPIO_OUTPUT_PP, GPIO_PULL_UP); // 假设按键一端接地，另一端连接 MCU 引脚，使用上拉输入
}

uint8_t Button_IsPressed(Button_ID_TypeDef button_id) {
    GPIO_Port_TypeDef port;
    GPIO_Pin_TypeDef pin;

    if (button_id == BUTTON_1) {
        port = BUTTON1_GPIO_PORT;
        pin = BUTTON1_GPIO_PIN;
    } else if (button_id == BUTTON_2) {
        port = BUTTON2_GPIO_PORT;
        pin = BUTTON2_GPIO_PIN;
    } else {
        return 0; //  无效的按键 ID，默认未按下
    }

    // ...  可以加入按键去抖动逻辑 (例如延时一段时间再次读取 GPIO 状态)
    return HAL_GPIO_ReadPin(port, pin) == 0; // 假设按键按下时 GPIO 输入为低电平
}

uint8_t Button_IsReleased(Button_ID_TypeDef button_id) {
    // ...  实现按键释放检测逻辑 (可以记录上一次的按键状态，与当前状态比较)
    return !Button_IsPressed(button_id);
}

uint8_t Button_IsLongPressed(Button_ID_TypeDef button_id) {
    // ...  实现按键长按检测逻辑 (需要使用定时器，在按键按下后开始计时，超过一定时间则认为是长按)
    return 0; //  暂未实现，留待后续扩展
}

3. System Services (系统服务层)

系统服务层的文件通常放在 services/ 目录下。

services/temperature_control.h

#ifndef TEMPERATURE_CONTROL_H
#define TEMPERATURE_CONTROL_H

#include <stdint.h>

// 初始化温度控制模块
void TemperatureControl_Init(void);

// 设置目标温度 (单位：摄氏度)
void TemperatureControl_SetTargetTemperature(float target_temp);

// 获取当前温度 (单位：摄氏度)
float TemperatureControl_GetCurrentTemperature(void);

// 运行温度控制循环 (需要在主循环或定时器中断中周期性调用)
void TemperatureControl_RunLoop(void);

#endif // TEMPERATURE_CONTROL_H

services/temperature_control.c

#include "temperature_control.h"
#include "drivers/temp_sensor.h"
#include "drivers/heater_control.h"

// PID 控制器参数 (需要根据实际系统进行整定)
#define KP  1.0f
#define KI  0.1f
#define KD  0.01f

static float target_temperature = 35.0f; // 默认目标温度 35℃
static float integral_error = 0.0f;
static float last_error = 0.0f;

void TemperatureControl_Init(void) {
    TempSensor_Init();
    Heater_Init();
}

void TemperatureControl_SetTargetTemperature(float target_temp) {
    target_temperature = target_temp;
    integral_error = 0.0f; // 更改目标温度时，重置积分项
}

float TemperatureControl_GetCurrentTemperature(void) {
    return TempSensor_ReadTemperature();
}

void TemperatureControl_RunLoop(void) {
    float current_temp = TempSensor_ReadTemperature();
    float error = target_temperature - current_temp;

    integral_error += error;

    // 积分项限幅，防止积分饱和 (wind-up)
    if (integral_error > 100.0f) integral_error = 100.0f;
    if (integral_error < -100.0f) integral_error = -100.0f;

    float derivative_error = error - last_error;
    last_error = error;

    float output_power = KP * error + KI * integral_error + KD * derivative_error;

    // 输出功率限幅 (0-100%)
    if (output_power > 100.0f) output_power = 100.0f;
    if (output_power < 0.0f) output_power = 0.0f;

    Heater_SetPower((uint8_t)output_power);
}

services/ui_manager.h

#ifndef UI_MANAGER_H
#define UI_MANAGER_H

#include <stdint.h>

// 初始化 UI 管理器
void UIManager_Init(void);

// 更新显示 (需要在主循环或定时器中断中周期性调用)
void UIManager_UpdateDisplay(float current_temp, float target_temp, uint8_t heater_power);

// 显示主界面
void UIManager_ShowMainScreen(float current_temp, float target_temp, uint8_t heater_power);

// 显示设置温度界面
void UIManager_ShowSetTemperatureScreen(float current_temp, float target_temp);

// ...  可以添加其他 UI 界面显示函数

#endif // UI_MANAGER_H

services/ui_manager.c

#include "ui_manager.h"
#include "drivers/display_driver.h"
#include "drivers/button_driver.h"
#include "services/temperature_control.h" // 为了获取温度和功率信息

#include <stdio.h> // 为了使用 sprintf

void UIManager_Init(void) {
    Display_Init();
    Display_Clear();
}

void UIManager_UpdateDisplay(float current_temp, float target_temp, uint8_t heater_power) {
    UIManager_ShowMainScreen(current_temp, target_temp, heater_power); // 默认更新主界面
}

void UIManager_ShowMainScreen(float current_temp, float target_temp, uint8_t heater_power) {
    Display_Clear();
    Display_SetCursor(0, 0);
    Display_WriteString("Current Temp:");
    Display_SetCursor(1, 0);
    Display_WriteFloat(current_temp, 1); // 显示一位小数
    Display_WriteString(" C");

    Display_SetCursor(0, 16); // 假设显示屏宽度足够
    Display_WriteString("Set Temp:");
    Display_SetCursor(1, 16);
    Display_WriteFloat(target_temp, 1);
    Display_WriteString(" C");

    Display_SetCursor(2, 0);
    Display_WriteString("Power:");
    Display_SetCursor(3, 0);
    Display_WriteInteger(heater_power);
    Display_WriteString(" %");
}

void UIManager_ShowSetTemperatureScreen(float current_temp, float target_temp) {
    Display_Clear();
    Display_SetCursor(0, 0);
    Display_WriteString("Set Temperature");
    Display_SetCursor(1, 0);
    Display_WriteString("Current:");
    Display_WriteFloat(current_temp, 1);
    Display_WriteString(" C");
    Display_SetCursor(2, 0);
    Display_WriteString("Setting:");
    Display_WriteFloat(target_temp, 1);
    Display_WriteString(" C");
    Display_SetCursor(3, 0);
    Display_WriteString("Use Button to Adjust");
}

services/settings_manager.h

#ifndef SETTINGS_MANAGER_H
#define SETTINGS_MANAGER_H

#include <stdint.h>

// 初始化设置管理器
void SettingsManager_Init(void);

// 加载设置
void SettingsManager_LoadSettings(void);

// 保存设置
void SettingsManager_SaveSettings(void);

// 获取目标温度
float SettingsManager_GetTargetTemperature(void);

// 设置目标温度
void SettingsManager_SetTargetTemperature(float target_temp);

#endif // SETTINGS_MANAGER_H

services/settings_manager.c

#include "settings_manager.h"
// ...  可能需要包含 Flash 或 EEPROM 驱动的头文件，用于持久化存储设置参数

static float current_target_temperature = 35.0f; // 默认目标温度

void SettingsManager_Init(void) {
    SettingsManager_LoadSettings(); // 初始化时加载上次保存的设置
}

void SettingsManager_LoadSettings(void) {
    // ...  从 Flash 或 EEPROM 中读取保存的设置参数 (例如目标温度)
    // ...  如果 Flash 或 EEPROM 中没有有效数据，则使用默认值
    // ...  (此处为硬件平台和存储介质相关的代码)

    // 示例 (假设直接使用默认值)
    current_target_temperature = 35.0f;
}

void SettingsManager_SaveSettings(void) {
    // ...  将当前设置参数 (例如目标温度) 保存到 Flash 或 EEPROM 中
    // ...  (此处为硬件平台和存储介质相关的代码)

    // 示例 (空实现，不保存)
}

float SettingsManager_GetTargetTemperature(void) {
    return current_target_temperature;
}

void SettingsManager_SetTargetTemperature(float target_temp) {
    current_target_temperature = target_temp;
    SettingsManager_SaveSettings(); //  每次设置后保存
}

services/safety_monitor.h

#ifndef SAFETY_MONITOR_H
#define SAFETY_MONITOR_H

#include <stdint.h>

// 初始化安全监控模块
void SafetyMonitor_Init(void);

// 运行安全监控检查 (需要在主循环或定时器中断中周期性调用)
void SafetyMonitor_RunCheck(float current_temp);

#endif // SAFETY_MONITOR_H

services/safety_monitor.c

#include "safety_monitor.h"
#include "drivers/heater_control.h"
// ...  可能需要包含错误处理和系统状态管理相关的头文件

#define OVER_TEMPERATURE_THRESHOLD 200.0f // 过温阈值，例如 200℃

void SafetyMonitor_Init(void) {
    // ...  初始化安全监控模块，例如配置错误指示 GPIO
}

void SafetyMonitor_RunCheck(float current_temp) {
    if (current_temp > OVER_TEMPERATURE_THRESHOLD) {
        // 检测到过温
        Heater_Disable(); // 关闭加热器
        // ...  可以添加错误指示，例如点亮 LED 或在显示屏上显示错误信息
        // ...  记录错误日志
        // ...  进入错误处理状态，例如停止系统运行
    }
}

4. Application Layer (应用层)

应用层的文件通常放在 app/ 目录下，或者直接放在项目根目录下。

app/main.c

#include <stdio.h>
#include "hal/hal_gpio.h"
#include "drivers/button_driver.h"
#include "services/temperature_control.h"
#include "services/ui_manager.h"
#include "services/settings_manager.h"
#include "services/safety_monitor.h"

#define BUTTON_INC BUTTON_1 // 假设 Button 1 用于增加温度
#define BUTTON_DEC BUTTON_2 // 假设 Button 2 用于减少温度

// 系统状态枚举
typedef enum {
    STATE_IDLE,
    STATE_SETTING_TEMP,
    STATE_HEATING,
    STATE_CONSTANT_TEMP,
    STATE_ERROR
} SystemState_TypeDef;

static SystemState_TypeDef current_state = STATE_IDLE;
static float current_target_temp = 35.0f; // 初始目标温度
static float current_temp_value = 0.0f;
static uint8_t current_heater_power = 0;

void System_Init(void) {
    // HAL 初始化 (根据实际 MCU 和硬件平台进行初始化)
    // ...  例如时钟初始化、外设时钟使能等

    Button_Init(BUTTON_INC);
    Button_Init(BUTTON_DEC);
    SettingsManager_Init();
    UIManager_Init();
    TemperatureControl_Init();
    SafetyMonitor_Init();

    current_target_temp = SettingsManager_GetTargetTemperature(); // 加载上次保存的目标温度
    TemperatureControl_SetTargetTemperature(current_target_temp); // 设置初始目标温度

    current_state = STATE_IDLE; // 初始状态为 IDLE
}

void System_RunState(void) {
    switch (current_state) {
        case STATE_IDLE:
            // ...  待机状态逻辑
            current_heater_power = 0; // 待机状态关闭加热器
            Heater_Disable();
            if (Button_IsPressed(BUTTON_INC) || Button_IsPressed(BUTTON_DEC)) {
                current_state = STATE_SETTING_TEMP; // 进入设置温度状态
                UIManager_ShowSetTemperatureScreen(current_temp_value, current_target_temp); // 显示设置温度界面
            }
            break;

        case STATE_SETTING_TEMP:
            // ...  设置温度状态逻辑
            if (Button_IsPressed(BUTTON_INC)) {
                current_target_temp += 1.0f; // 每次按键增加 1℃
                if (current_target_temp > 300.0f) current_target_temp = 300.0f; // 温度上限
                SettingsManager_SetTargetTemperature(current_target_temp); // 保存设置
                UIManager_ShowSetTemperatureScreen(current_temp_value, current_target_temp); // 更新显示
                // ...  可以加入按键长按加速调节逻辑
            }
            if (Button_IsPressed(BUTTON_DEC)) {
                current_target_temp -= 1.0f; // 每次按键减少 1℃
                if (current_target_temp < 25.0f) current_target_temp = 25.0f;   // 温度下限 (例如室温)
                SettingsManager_SetTargetTemperature(current_target_temp); // 保存设置
                UIManager_ShowSetTemperatureScreen(current_temp_value, current_target_temp); // 更新显示
                // ...  可以加入按键长按加速调节逻辑
            }
            if (Button_IsReleased(BUTTON_INC) || Button_IsReleased(BUTTON_DEC)) {
                // 按键释放，返回主界面并开始加热
                current_state = STATE_HEATING;
                TemperatureControl_SetTargetTemperature(current_target_temp); // 设置目标温度
            }
            break;

        case STATE_HEATING:
        case STATE_CONSTANT_TEMP: // 恒温状态与加热状态类似，可以合并处理，或者根据实际需求细分
            // ...  加热和恒温状态逻辑
            TemperatureControl_RunLoop(); // 运行温度控制 PID 循环
            current_temp_value = TemperatureControl_GetCurrentTemperature();
            current_heater_power = (uint8_t)(Heater_GetPowerPercentage()); // 获取加热器功率百分比 (需要 Heater_SetPower 返回实际设置的功率百分比或提供获取功率百分比的接口)
            UIManager_UpdateDisplay(current_temp_value, current_target_temp, current_heater_power); // 更新显示
            SafetyMonitor_RunCheck(current_temp_value); // 运行安全监控

            if (Button_IsPressed(BUTTON_INC) || Button_IsPressed(BUTTON_DEC)) {
                current_state = STATE_SETTING_TEMP; // 再次进入设置温度状态
                UIManager_ShowSetTemperatureScreen(current_temp_value, current_target_temp); // 显示设置温度界面
            }

            // ...  可以根据实际需求添加状态切换条件，例如达到目标温度后进入恒温状态 (STATE_CONSTANT_TEMP)
            break;

        case STATE_ERROR:
            // ...  错误状态逻辑，例如显示错误信息，停止加热等
            Heater_Disable();
            UIManager_ClearDisplay();
            UIManager_WriteString("System Error!");
            // ...  可以显示具体的错误代码或错误信息
            break;

        default:
            current_state = STATE_IDLE; //  未知状态，返回 IDLE
            break;
    }
}

int main(void) {
    System_Init();

    while (1) {
        System_RunState();
        // ...  其他后台任务，例如数据采集、通信等 (如果需要)
        // ...  可以加入延时，控制主循环执行频率 (例如 10ms 或 100ms)
        // HAL_Delay(10); //  使用 HAL 库提供的延时函数 (需要根据实际情况调整)
    }
}

代码说明:

模块化: 代码按照分层架构和模块化设计，每个文件负责特定的功能，易于理解和维护。
可读性: 代码风格力求清晰易懂，添加了必要的注释。
可扩展性: 分层架构为后续扩展功能提供了良好的基础。例如，可以很容易地添加新的显示界面、更复杂的控制算法、通信接口等。
实用性: 代码示例涵盖了嵌入式系统开发中常用的技术和方法，例如HAL层硬件抽象、设备驱动、系统服务、状态机、PID控制、UI管理、参数存储、安全监控等。
代码量: 虽然示例代码本身可能不足 3000 行，但如果加上 HAL 层和驱动层的完整实现，以及更详细的错误处理、边界条件检查、硬件平台初始化代码、以及更丰富的功能实现（例如菜单界面、更复杂的控制算法、通信接口等），代码量很容易超过 3000 行。

后续扩展方向:

更完善的 HAL 和驱动: 根据具体的 MCU 和硬件平台，完善 HAL 层和设备驱动层的代码，包括详细的初始化配置、错误处理、中断处理等。
更丰富的 UI 界面: 增加菜单界面、参数设置界面、实时曲线显示等更复杂的用户界面。
更高级的控制算法: 可以尝试更高级的控制算法，例如模糊PID、自适应PID等，以提高温度控制的精度和响应速度。
数据记录和分析: 增加温度数据记录功能，可以将温度数据存储到 Flash 或 SD 卡中，方便后续分析。
上位机通信: 增加 USB 或串口通信接口，实现与上位机软件的通信，可以进行远程控制、数据监控、固件升级等。
更完善的安全特性: 增加过流保护、短路保护、传感器故障检测等更完善的安全特性。
低功耗设计: 如果需要电池供电，可以考虑加入低功耗设计，例如使用 MCU 的低功耗模式、优化代码执行效率、降低显示屏功耗等。

总结

这个迷你加热台嵌入式系统代码设计架构和C代码示例，提供了一个可靠、高效、可扩展的系统平台的基础框架。通过分层架构和模块化设计，代码结构清晰，易于理解和维护。您可以基于这个框架，根据实际的硬件平台和需求，逐步完善和扩展功能，最终构建一个功能完善、性能优良的迷你加热台产品。

希望这个详细的解答能够帮助您！