第2章嵌入式C语言基础回顾

第2章嵌入式C语言基础回顾：指针与内存管理、结构体与联合体、位运算与寄存器操作、函数指针与回调机制

各位同学，欢迎来到第二章。

说实话，很多做嵌入式开发的朋友，C语言基础其实并不扎实。尤其是做TCU开发，你面对的是直接操作硬件、管理有限内存、处理实时中断的严苛环境。这一章，我带你把这四个核心知识点彻底捋一遍。这些都是我这些年踩坑踩出来的经验，你学会了，能少走很多弯路。

2.1 指针与内存管理：TCU的"命脉"

指针，说白了就是地址。但在TCU里，它不仅仅是地址，更是你访问硬件寄存器的唯一途径。

2.1.1 指针的本质与用法

我习惯把指针理解成"门牌号"。你拿着门牌号，就能找到那间屋子，取出里面的东西。在TCU中，这个"屋子"可能是某个传感器的数据缓冲区，也可能是变速箱的某个控制寄存器。

// 定义一个指向uint32类型的指针
uint32_t *p_reg;

// 假设某个寄存器的地址是0x40020000
p_reg = (uint32_t *)0x40020000;

// 读取该寄存器的值
uint32_t reg_value = *p_reg;

// 写入新值
*p_reg = 0x01;

嗯，这里要注意：强制类型转换是必须的。编译器不会允许你直接把一个整数当作指针用，你得明确告诉它："我知道我在干什么。"

警告： 我曾经在项目里见过有人直接写 *(uint32_t *)0x40020000 = 0x01; 然后忘了加括号，结果编译报错。记住，强制转换和取内容，优先级要搞清楚。

2.1.2 动态内存管理：能不用就不用

在TCU这种实时性要求极高的系统里，我个人的建议是：尽量避免使用malloc/free。为什么？因为动态分配会导致内存碎片，而且分配时间不确定。你想想看，变速箱在换挡的瞬间，突然因为malloc耗时过长导致响应延迟，那后果是什么？

如果真的需要动态管理，我建议使用静态内存池。提前分配好固定大小的内存块，用链表管理起来。这样分配和释放的时间都是确定的。

// 简单的静态内存池示例
#define POOL_SIZE 10
#define BLOCK_SIZE 32

static uint8_t memory_pool[POOL_SIZE][BLOCK_SIZE];
static uint8_t pool_used[POOL_SIZE] = {0};

void* pool_alloc(void) {
    for (int i = 0; i < POOL_SIZE; i++) {
        if (!pool_used[i]) {
            pool_used[i] = 1;
            return (void*)memory_pool[i];
        }
    }
    return NULL; // 池子满了
}

void pool_free(void *ptr) {
    // 计算索引，标记为未使用
}

技巧： 我在做TCU项目时，所有通信缓冲区、传感器数据缓存，都用这种静态池。简单、可靠、速度快。

2.2 结构体与联合体：数据组织的艺术

结构体和联合体，是嵌入式C语言里组织数据的利器。尤其是联合体，很多人觉得它鸡肋，其实在寄存器操作中，它特别好用。

2.2.1 结构体：打包数据

在TCU中，一个传感器可能返回多个值：温度、压力、转速。用结构体把它们打包在一起，代码可读性会好很多。

typedef struct {
    uint16_t temperature;  // 温度，单位0.1°C
    uint16_t pressure;     // 压力，单位kPa
    uint16_t speed;        // 转速，单位rpm
} SensorData_t;

SensorData_t gearbox_sensor;
gearbox_sensor.temperature = 850; // 85.0°C

我个人习惯在结构体定义后面加 _t 后缀，一眼就能看出这是个类型定义。这个小习惯，在大型项目中能省不少事。

2.2.2 联合体：同一内存，不同解读

联合体允许你在同一块内存地址上，用不同的数据类型去解读它。这在解析通信协议或者操作寄存器时特别有用。

typedef union {
    uint32_t full_value;      // 整个32位寄存器
    struct {
        uint8_t byte0;        // 最低字节
        uint8_t byte1;
        uint8_t byte2;
        uint8_t byte3;        // 最高字节
    } bytes;
} Register32_t;

Register32_t reg;
reg.full_value = 0x12345678;
// 现在 reg.bytes.byte0 就是 0x78
// reg.bytes.byte3 就是 0x12

  重点： 联合体的大小由最大的成员决定。上面的例子中，Register32_t 的大小就是4字节。你修改 bytes.byte0，实际上就修改了 full_value 的最低8位。

2.3 位运算与寄存器操作：TCU的"肌肉记忆"

位运算，是嵌入式工程师的基本功。在TCU中，你几乎每天都在跟寄存器打交道。设置某个位、清除某个位、检查某个位，这些操作必须烂熟于心。

2.3.1 基本位运算操作

操作	运算符	示例	说明
置位	\|	`REG \|= (1 << 3);`	将第3位置1
清零	& ~	`REG &= ~(1 << 3);`	将第3位清0
取反	^	`REG ^= (1 << 3);`	将第3位翻转
检查	&	`if (REG & (1 << 3))`	检查第3位是否为1

你想想看，如果不用位运算，你可能会写出 REG = REG | 0x08; 这样的代码。虽然也能工作，但可读性差远了。用 (1 << 3) 一目了然，第3位。

2.3.2 实战：操作TCU控制寄存器

假设我们有一个变速箱控制寄存器 TCU_CTRL，它的位定义如下：

Bit 0: 使能位 (ENABLE)
Bit 1-3: 模式选择 (MODE)，共8种模式
Bit 4: 中断标志 (INT_FLAG)

#define TCU_CTRL_ADDR  0x40021000
#define TCU_CTRL       (*(volatile uint32_t *)TCU_CTRL_ADDR)

// 定义位掩码
#define ENABLE_BIT     (1 << 0)
#define MODE_MASK      (0x07 << 1)  // 位1-3
#define INT_FLAG_BIT   (1 << 4)

// 使能TCU
TCU_CTRL |= ENABLE_BIT;

// 设置模式为3 (二进制011)
TCU_CTRL &= ~MODE_MASK;          // 先清除模式位
TCU_CTRL |= (0x03 << 1);        // 再设置新模式

// 检查中断标志
if (TCU_CTRL & INT_FLAG_BIT) {
    // 处理中断
    // 清除中断标志（通常写1清零）
    TCU_CTRL |= INT_FLAG_BIT;
}

注意： 操作寄存器时，一定要用 volatile 关键字。我曾经因为忘了加 volatile，编译器优化后把寄存器值缓存了，导致中断标志一直读不到新状态。排查了整整一天！

2.4 函数指针与回调机制：让代码"活"起来

函数指针，说白了就是指向函数的指针。它让你的代码具有了"动态"的能力。在TCU中，回调机制常用于中断处理、状态机跳转等场景。

2.4.1 函数指针的定义与使用

// 定义一个函数指针类型，指向一个返回void、参数为uint32_t的函数
typedef void (*CallbackFunc_t)(uint32_t);

// 一个具体的回调函数
void GearChangeHandler(uint32_t gear) {
    // 处理换挡逻辑
    printf("换到第%d档\n", gear);
}

// 注册回调
CallbackFunc_t p_callback = GearChangeHandler;

// 调用回调
p_callback(3);  // 相当于调用 GearChangeHandler(3)

2.4.2 回调机制在TCU中的应用

我做过的一个TCU项目中，换挡策略是一个状态机。每个状态都有一个进入函数、一个执行函数、一个退出函数。用函数指针数组来管理，代码非常简洁。

// 定义状态机中的函数指针
typedef void (*StateFunc_t)(void);

// 各个状态的处理函数
void State_Idle_Enter(void) { /* ... */ }
void State_Idle_Execute(void) { /* ... */ }
void State_Idle_Exit(void) { /* ... */ }

void State_Shift_Enter(void) { /* ... */ }
void State_Shift_Execute(void) { /* ... */ }
void State_Shift_Exit(void) { /* ... */ }

// 状态函数表
typedef struct {
    StateFunc_t enter;
    StateFunc_t execute;
    StateFunc_t exit;
} StateTable_t;

// 定义所有状态
StateTable_t state_table[] = {
    [0] = {State_Idle_Enter, State_Idle_Execute, State_Idle_Exit},
    [1] = {State_Shift_Enter, State_Shift_Execute, State_Shift_Exit},
    // ... 更多状态
};

// 当前状态
uint8_t current_state = 0;

// 状态机执行
void StateMachine_Run(void) {
    state_table[current_state].execute();
}

// 状态切换
void StateMachine_Change(uint8_t new_state) {
    state_table[current_state].exit();    // 退出当前状态
    current_state = new_state;
    state_table[current_state].enter();   // 进入新状态
}

技巧： 用函数指针表来实现状态机，比用switch-case要灵活得多。增加一个新状态，只需要添加一个函数和一个表项，不需要修改核心逻辑。我在多个TCU项目中都用这个模式，维护起来特别方便。

本章小结

这一章的内容，是TCU开发的基石。指针让你能直接操作硬件，结构体和联合体帮你组织数据，位运算让你精准控制寄存器，函数指针则让你的代码具备动态扩展能力。

说实话，这些知识点单独看都不难，但要在实际项目中用好，需要大量的练习和思考。我建议你，把本章的代码示例都亲手敲一遍，然后在开发板上跑一跑。遇到问题不要怕，那都是你成长的阶梯。

下一章，我们将进入TCU的核心——状态机与换挡逻辑设计。准备好了吗？

  课后思考： 如果你用联合体来操作一个32位的寄存器，如何确保大小端模式不影响你的位域访问？试试看，写一段代码验证你的想法。

📚 课程目录