11、C语言程序设计：_FUNCTION__ 宏在嵌入式开发中的应用

C语言程序设计：_FUNCTION__ 宏在嵌入式开发中的应用

数字化与智能化

493人浏览 · 2026-01-28 17:02:04

数字化与智能化 · 2026-01-28 17:02:04 发布

1. 基本介绍

__FUNCTION__ 是C语言的一个特殊预定义标识符，它在编译时会被替换为当前函数的名字（字符串常量）。

__FUNCTION__ 的主要优势：
【1】自动获取函数名 - 无需手动输入，减少错误
【2】代码维护方便 - 函数重命名时自动更新
【3】调试效率高 - 快速定位问题来源
【4】日志信息丰富 - 提供完整的调用上下文

在嵌入式系统中的实际应用：
【1】故障诊断 - 快速定位硬件故障位置
【2】性能优化 - 识别瓶颈函数
【3】状态跟踪 - 监控系统运行状态
【4】远程调试 - 通过日志分析现场问题
【5】代码审查 - 理解函数调用关系

2. 各种用法及示例

2.1 基本调试打印

include <stdio.h>

void calculate_sum(int a, int b) {
printf("函数 %s 被调用，参数：%d, %d\n", __FUNCTION__, a, b);
int result = a + b;
printf("函数 %s 计算完成，结果：%d\n", __FUNCTION__, result);
}

int main() {
calculate_sum(5, 3);
return 0;
}

输出：

函数 calculate_sum 被调用，参数：5, 3
函数 calculate_sum 计算完成，结果：8

2.2 错误处理和日志记录

include <stdio.h>
include <stdlib.h>

define LOG_ERROR(msg) \
fprintf(stderr, "错误[%s]: %s\n", __FUNCTION__, msg)

int divide(int a, int b) {
if (b == 0) {
LOG_ERROR("除数不能为零");
return 0;
}
return a / b;
}

int allocate_memory(int size) {
void ptr = malloc(size);
if (ptr == NULL) {
LOG_ERROR("内存分配失败");
return -1;
}
return 0;
}

int main() {
divide(10, 0);
allocate_memory(1000000000);
return 0;
}

输出：

错误[divide]: 除数不能为零
错误[allocate_memory]: 内存分配失败

2.3 性能分析和函数追踪

include <stdio.h>
include <time.h>

define TRACE_ENTER() \
printf(">>> 进入函数：%s\n", __FUNCTION__)

define TRACE_EXIT() \
printf("<<< 退出函数：%s\n", __FUNCTION__)

define TIME_FUNCTION(func_call) \
do { \
clock_t start = clock(); \
func_call; \
clock_t end = clock(); \
double duration = (double)(end - start) / CLOCKS_PER_SEC; \
printf("函数执行时间：%f 秒\n", duration); \
} while(0)

void process_data() {
TRACE_ENTER();
// 模拟耗时操作
for (int i = 0; i < 1000000; i++);
TRACE_EXIT();
}

void another_function() {
TRACE_ENTER();
printf("正在执行任务...\n");
TRACE_EXIT();
}

int main() {
TIME_FUNCTION(process_data());
TIME_FUNCTION(another_function());
return 0;
}

输出：

>>> 进入函数：process_data
<<< 退出函数：process_data
函数执行时间：0.005000 秒
>>> 进入函数：another_function
正在执行任务...
<<< 退出函数：another_function
函数执行时间：0.001000 秒

2.4 函数调用链追踪

include <stdio.h>

define MAX_CALL_DEPTH 10
int call_depth = 0;

define ENTER_FUNCTION() \
do { \
call_depth++; \
if (call_depth <= MAX_CALL_DEPTH) { \
for (int i = 0; i < call_depth; i++) printf(" "); \
printf("-> %s()\n", __FUNCTION__); \
} \
} while(0)

define EXIT_FUNCTION() \
do { \
if (call_depth <= MAX_CALL_DEPTH) { \
for (int i = 0; i < call_depth; i++) printf(" "); \
printf("<- %s()\n", __FUNCTION__); \
} \
call_depth--; \
} while(0)

void function_c() {
ENTER_FUNCTION();
printf(" 执行function_c的任务\n");
EXIT_FUNCTION();
}

void function_b() {
ENTER_FUNCTION();
printf(" 执行function_b的任务\n");
function_c();
EXIT_FUNCTION();
}

void function_a() {
ENTER_FUNCTION();
printf(" 执行function_a的任务\n");
function_b();
EXIT_FUNCTION();
}

int main() {
ENTER_FUNCTION();
function_a();
EXIT_FUNCTION();
return 0;
}

输出：

-> main()
-> function_a()
执行function_a的任务
-> function_b()
执行function_b的任务
-> function_c()
执行function_c的任务
<- function_c()
<- function_b()
<- function_a()
<- main()

2.5 条件编译和调试级别控制

include <stdio.h>

// 调试级别：0=关闭，1=基本，2=详细，3=全部
define DEBUG_LEVEL 2

if DEBUG_LEVEL >= 1
define DEBUG_INFO(msg, ...) \
printf("[INFO][%s] " msg "\n", __FUNCTION__, __VA_ARGS__)
else
define DEBUG_INFO(msg, ...)
endif

if DEBUG_LEVEL >= 2
define DEBUG_DETAIL(msg, ...) \
printf("[DETAIL][%s] " msg "\n", __FUNCTION__, __VA_ARGS__)
else
define DEBUG_DETAIL(msg, ...)
endif

if DEBUG_LEVEL >= 3
define DEBUG_VERBOSE(msg, ...) \
printf("[VERBOSE][%s] " msg "\n", __FUNCTION__, __VA_ARGS__)
else
define DEBUG_VERBOSE(msg, ...)
endif

void initialize_system() {
DEBUG_INFO("系统初始化开始");
DEBUG_DETAIL("分配内存...");
DEBUG_VERBOSE("内存地址: %p", malloc(100));
DEBUG_INFO("系统初始化完成");
}

void process_user_input(int input) {
DEBUG_INFO("处理用户输入: %d", input);
DEBUG_DETAIL("验证输入有效性...");
if (input < 0) {
DEBUG_INFO("输入无效");
}
}

int main() {
DEBUG_INFO("程序启动");
initialize_system();
process_user_input(42);
process_user_input(-5);
DEBUG_INFO("程序结束");
return 0;
}

输出（DEBUG_LEVEL=2时）：

[INFO][main] 程序启动
[INFO][initialize_system] 系统初始化开始
[DETAIL][initialize_system] 分配内存...
[INFO][initialize_system] 系统初始化完成
[INFO][process_user_input] 处理用户输入: 42
[DETAIL][process_user_input] 验证输入有效性...
[INFO][process_user_input] 处理用户输入: -5
[DETAIL][process_user_input] 验证输入有效性...
[INFO][process_user_input] 输入无效
[INFO][main] 程序结束

2.6 状态机函数追踪

include <stdio.h>

typedef enum {
STATE_IDLE,
STATE_RUNNING,
STATE_PAUSED,
STATE_ERROR
} SystemState;

SystemState current_state = STATE_IDLE;

define STATE_TRANSITION(new_state) \
do { \
printf("状态转移 [%s]: %d -> %d\n", \
__FUNCTION__, current_state, new_state); \
current_state = new_state; \
} while(0)

void start_system() {
if (current_state == STATE_IDLE) {
STATE_TRANSITION(STATE_RUNNING);
printf("系统启动成功\n");
} else {
printf("当前状态无法启动系统\n");
}
}

void pause_system() {
if (current_state == STATE_RUNNING) {
STATE_TRANSITION(STATE_PAUSED);
printf("系统已暂停\n");
}
}

void resume_system() {
if (current_state == STATE_PAUSED) {
STATE_TRANSITION(STATE_RUNNING);
printf("系统恢复运行\n");
}
}

void error_occurred() {
STATE_TRANSITION(STATE_ERROR);
printf("发生错误，系统进入错误状态\n");
}

int main() {
start_system();
pause_system();
resume_system();
error_occurred();
return 0;
}

输出：

状态转移 [start_system]: 0 -> 1
系统启动成功
状态转移 [pause_system]: 1 -> 2
系统已暂停
状态转移 [resume_system]: 2 -> 1
系统恢复运行
状态转移 [error_occurred]: 1 -> 3
发生错误，系统进入错误状态

3. 嵌入式系统综合示例

/
智能温控系统 - 嵌入式综合示例
功能：控制加热器、风扇、读取温度传感器、记录日志
/

include <stdio.h>
include <stdint.h>
include <string.h>

// ==================== 模拟硬件接口 ====================
typedef struct {
uint8_t heater_power; // 加热器功率 0-100%
uint8_t fan_speed; // 风扇速度 0-100%
float current_temp; // 当前温度 °C
float target_temp; // 目标温度 °C
} SystemController;

// 模拟硬件寄存器
SystemController hw_ctrl = {0};

// ==================== 日志系统 ====================
// 日志级别
typedef enum {
LOG_LEVEL_ERROR = 1,
LOG_LEVEL_WARNING = 2,
LOG_LEVEL_INFO = 3,
LOG_LEVEL_DEBUG = 4
} LogLevel;

// 当前日志级别（可通过配置修改）
LogLevel current_log_level = LOG_LEVEL_INFO;

// 日志记录宏
define LOG(level, format, ...) \
do { \
if ((level) <= current_log_level) { \
const char level_str; \
switch(level) { \
case LOG_LEVEL_ERROR: level_str = "ERROR"; break; \
case LOG_LEVEL_WARNING: level_str = "WARNING"; break; \
case LOG_LEVEL_INFO: level_str = "INFO"; break; \
case LOG_LEVEL_DEBUG: level_str = "DEBUG"; break; \
default: level_str = "UNKNOWN"; break; \
} \
char log_buffer[128]; \
snprintf(log_buffer, sizeof(log_buffer), \
"[%s][%s] " format "\n", \
level_str, __FUNCTION__, __VA_ARGS__); \
/ 实际嵌入式系统中可能输出到串口或SD卡 / \
printf("%s", log_buffer); \
} \
} while(0)

// ==================== 错误处理系统 ====================
define CHECK_TEMP_RANGE(temp) \
do { \
if ((temp) < -40.0 || (temp) > 150.0) { \
LOG(LOG_LEVEL_ERROR, "温度超出范围: %.2f°C", temp); \
emergency_shutdown(); \
return -1; \
} \
} while(0)

define CHECK_HARDWARE_STATUS() \
do { \
if (!is_hardware_ready()) { \
LOG(LOG_LEVEL_ERROR, "硬件未就绪"); \
return -2; \
} \
} while(0)

// ==================== 性能监控 ====================
ifdef PERFORMANCE_MONITORING
define PERF_START() \
uint32_t perf_start_time = get_system_tick()

define PERF_END(operation_name) \
do { \
uint32_t perf_end_time = get_system_tick(); \
uint32_t perf_duration = perf_end_time - perf_start_time; \
LOG(LOG_LEVEL_DEBUG, "%s 耗时: %u ms", \
operation_name, perf_duration); \
} while(0)
else
define PERF_START()
define PERF_END(operation_name)
endif

// ==================== 硬件控制函数 ====================
int set_heater_power(uint8_t power) {
LOG(LOG_LEVEL_INFO, "设置加热器功率: %d%%", power);

CHECK_HARDWARE_STATUS();

if (power > 100) {
LOG(LOG_LEVEL_WARNING, "功率值 %d 超过上限，限制为 100%%", power);
power = 100;
}

hw_ctrl.heater_power = power;

// 模拟硬件设置
LOG(LOG_LEVEL_DEBUG, "加热器功率已更新");
return 0;
}

int set_fan_speed(uint8_t speed) {
LOG(LOG_LEVEL_INFO, "设置风扇速度: %d%%", speed);

CHECK_HARDWARE_STATUS();

if (speed > 100) {
LOG(LOG_LEVEL_WARNING, "速度值 %d 超过上限，限制为 100%%", speed);
speed = 100;
}

hw_ctrl.fan_speed = speed;

LOG(LOG_LEVEL_DEBUG, "风扇速度已更新");
return 0;
}

float read_temperature_sensor(int sensor_id) {
LOG(LOG_LEVEL_DEBUG, "读取传感器 %d", sensor_id);

PERF_START();

// 模拟传感器读取（实际可能是I2C/SPI通信）
float temp = 25.0 + (sensor_id 0.5); // 模拟温度

CHECK_TEMP_RANGE(temp);

PERF_END("读取温度传感器");

LOG(LOG_LEVEL_INFO, "传感器 %d 温度: %.2f°C", sensor_id, temp);
return temp;
}

// ==================== 核心控制逻辑 ====================
void temperature_control_loop(void) {
LOG(LOG_LEVEL_INFO, "温度控制循环开始");

// 读取所有传感器
float temp1 = read_temperature_sensor(1);
float temp2 = read_temperature_sensor(2);

// 计算平均温度
float avg_temp = (temp1 + temp2) / 2.0;
hw_ctrl.current_temp = avg_temp;

LOG(LOG_LEVEL_INFO, "平均温度: %.2f°C, 目标温度: %.2f°C",
avg_temp, hw_ctrl.target_temp);

// PID控制逻辑（简化版）
float error = hw_ctrl.target_temp - avg_temp;

if (error > 2.0) {
// 需要加热
uint8_t power = (uint8_t)(error 20.0);
if (power > 100) power = 100;
set_heater_power(power);
set_fan_speed(30); // 低速风扇帮助热交换
}
else if (error < -2.0) {
// 需要降温
set_heater_power(0);
uint8_t speed = (uint8_t)(-error 30.0);
if (speed > 100) speed = 100;
set_fan_speed(speed);
}
else {
// 维持温度
set_heater_power(20);
set_fan_speed(20);
LOG(LOG_LEVEL_INFO, "温度稳定在目标范围内");
}

LOG(LOG_LEVEL_INFO, "温度控制循环结束");
}

// ==================== 系统管理函数 ====================
int initialize_system(void) {
LOG(LOG_LEVEL_INFO, "系统初始化开始");

// 初始化硬件
if (initialize_hardware() != 0) {
LOG(LOG_LEVEL_ERROR, "硬件初始化失败");
return -1;
}

// 设置默认参数
hw_ctrl.target_temp = 25.0;
hw_ctrl.heater_power = 0;
hw_ctrl.fan_speed = 0;

LOG(LOG_LEVEL_INFO, "目标温度设置为: %.2f°C", hw_ctrl.target_temp);
LOG(LOG_LEVEL_INFO, "系统初始化完成");
return 0;
}

void set_target_temperature(float temp) {
LOG(LOG_LEVEL_INFO, "设置目标温度: %.2f°C", temp);

CHECK_TEMP_RANGE(temp);

hw_ctrl.target_temp = temp;

LOG(LOG_LEVEL_INFO, "目标温度已更新");
}

void emergency_shutdown(void) {
LOG(LOG_LEVEL_ERROR, "紧急关闭系统");

// 关闭所有输出
hw_ctrl.heater_power = 0;
hw_ctrl.fan_speed = 0;

LOG(LOG_LEVEL_INFO, "系统已安全关闭");
}

// ==================== 辅助函数（模拟） ====================
int initialize_hardware(void) {
LOG(LOG_LEVEL_DEBUG, "初始化硬件");
// 模拟硬件初始化
return 0;
}

int is_hardware_ready(void) {
// 模拟硬件状态检查
return 1;
}

uint32_t get_system_tick(void) {
// 模拟系统时钟
static uint32_t tick = 0;
return tick++;
}

// ==================== 主函数 ====================
int main(void) {
LOG(LOG_LEVEL_INFO, "智能温控系统启动");

// 初始化系统
if (initialize_system() != 0) {
LOG(LOG_LEVEL_ERROR, "系统启动失败");
return 1;
}

// 设置目标温度
set_target_temperature(30.0);

// 运行几个控制循环
for (int i = 0; i < 3; i++) {
LOG(LOG_LEVEL_INFO, "========== 控制循环 %d ==========", i + 1);
temperature_control_loop();
}

// 改变目标温度
set_target_temperature(20.0);

// 再运行几个控制循环
for (int i = 0; i < 2; i++) {
LOG(LOG_LEVEL_INFO, "========== 控制循环 %d ==========", i + 4);
temperature_control_loop();
}

// 测试错误情况
LOG(LOG_LEVEL_INFO, "========== 测试错误处理 ==========");
set_target_temperature(200.0); // 超出范围

LOG(LOG_LEVEL_INFO, "系统运行完成");
return 0;
}

示例输出：

[INFO][main] 智能温控系统启动
[INFO][initialize_system] 系统初始化开始
[DEBUG][initialize_hardware] 初始化硬件
[INFO][initialize_system] 目标温度设置为: 25.0°C
[INFO][initialize_system] 系统初始化完成
[INFO][set_target_temperature] 设置目标温度: 30.0°C
[INFO][set_target_temperature] 目标温度已更新
[INFO][main] ========== 控制循环 1 ==========
[INFO][temperature_control_loop] 温度控制循环开始
[DEBUG][read_temperature_sensor] 读取传感器 1
[INFO][read_temperature_sensor] 传感器 1 温度: 25.5°C
[DEBUG][read_temperature_sensor] 读取传感器 2
[INFO][read_temperature_sensor] 传感器 2 温度: 26.0°C
[INFO][temperature_control_loop] 平均温度: 25.75°C, 目标温度: 30.0°C
[INFO][set_heater_power] 设置加热器功率: 85%
[DEBUG][set_heater_power] 加热器功率已更新
[INFO][set_fan_speed] 设置风扇速度: 30%
[DEBUG][set_fan_speed] 风扇速度已更新
[INFO][temperature_control_loop] 温度控制循环结束
...
[ERROR][set_target_temperature] 温度超出范围: 200.0°C
[ERROR][emergency_shutdown] 紧急关闭系统
[INFO][emergency_shutdown] 系统已安全关闭