大家好，我是杂烩君。

在嵌入式开发里，有哪些常用的软件工程方法呢？

一、面向对象编程（OOP）

尽管 C 语言并非面向对象编程语言，但借助一些编程技巧，也能实现面向对象编程（OOP）的核心特性，如封装、继承和多态。

1. 封装

封装是把数据和操作数据的函数捆绑在一起，对外部隐藏内部实现细节。在嵌入式 C 语言中，可通过结构体和函数指针来实现封装。

#include <stdio.h>

// 定义一个LED结构体
typedef struct {
    int pin;
    void (*turnOn)(struct LED*);
    void (*turnOff)(struct LED*);
} LED;

// 实现LED开启函数
void ledTurnOn(LED* led) {
    printf("LED on pin %d is turned on.\n", led->pin);
}

// 实现LED关闭函数
void ledTurnOff(LED* led) {
    printf("LED on pin %d is turned off.\n", led->pin);
}

// 初始化LED
void ledInit(LED* led, int pin) {
    led->pin = pin;
    led->turnOn = ledTurnOn;
    led->turnOff = ledTurnOff;
}

int main(void) {
    LED myLed;
    ledInit(&myLed, 13);
    myLed.turnOn(&myLed);
    myLed.turnOff(&myLed);
    return 0;
}

LED结构体封装了pin数据和turnOn、turnOff函数指针。ledInit函数用于初始化LED结构体，把具体的函数赋值给函数指针。外部代码仅能通过这些函数指针来操作LED，而无需了解内部实现细节。

2. 继承

继承是指一个对象直接使用另一对象的属性和方法。在嵌入式 C 语言中，可通过结构体嵌套实现继承。

#include <stdio.h>

// 定义一个基类结构体
typedef struct {
    int id;
    void (*printInfo)(struct Base*);
} Base;

// 实现基类的打印信息函数
void basePrintInfo(Base* base) {
    printf("Base ID: %d\n", base->id);
}

// 定义一个派生类结构体
typedef struct {
    Base base; // 继承Base结构体
    char* name;
} Derived;

// 实现派生类的打印信息函数
void derivedPrintInfo(Derived* derived) {
    basePrintInfo(&derived->base);
    printf("Derived Name: %s\n", derived->name);
}

// 初始化基类
void baseInit(Base* base, int id) {
    base->id = id;
    base->printInfo = basePrintInfo;
}

// 初始化派生类
void derivedInit(Derived* derived, int id, char* name) {
    baseInit(&derived->base, id);
    derived->name = name;
    derived->base.printInfo = (void (*)(Base*))derivedPrintInfo;
}

int main(void) {
    Derived myDerived;
    derivedInit(&myDerived, 1, "Derived Object");
    myDerived.base.printInfo((Base*)&myDerived);
    return 0;
}

Derived结构体嵌套了Base结构体，从而继承了Base结构体的属性和方法。derivedInit函数在初始化Derived结构体时，会调用baseInit函数初始化基类部分，并且把printInfo函数指针指向derivedPrintInfo函数。

3. 多态

多态是指不同对象对同一消息做出不同响应。在嵌入式 C 语言中，可通过函数指针实现多态。

#include <stdio.h>

// 定义一个基类结构体
typedef struct {
    void (*operation)(struct Base*);
} Base;

// 定义一个派生类1结构体
typedef struct {
    Base base;
} Derived1;

// 定义一个派生类2结构体
typedef struct {
    Base base;
} Derived2;

// 派生类1的操作函数
void derived1Operation(Base* base) {
    printf("Derived1 operation.\n");
}

// 派生类2的操作函数
void derived2Operation(Base* base) {
    printf("Derived2 operation.\n");
}

// 初始化派生类1
void derived1Init(Derived1* derived1) {
    derived1->base.operation = derived1Operation;
}

// 初始化派生类2
void derived2Init(Derived2* derived2) {
    derived2->base.operation = derived2Operation;
}

// 执行操作
void performOperation(Base* base) {
    base->operation(base);
}

int main(void) {
    Derived1 myDerived1;
    Derived2 myDerived2;
    derived1Init(&myDerived1);
    derived2Init(&myDerived2);

    performOperation((Base*)&myDerived1);
    performOperation((Base*)&myDerived2);
    return 0;
}

Base结构体包含一个函数指针operation。Derived1和Derived2结构体继承了Base结构体，并分别实现了自己的operation函数。performOperation函数接收一个Base指针，依据具体对象调用相应的operation函数，从而实现了多态。

二、测试驱动开发（TDD）

测试驱动开发（Test-Driven Development，TDD）是一种软件开发方法论，它强调在编写实际功能代码之前先编写测试代码。

TDD 的核心流程遵循 “红 - 绿 - 重构” 循环，下面将详细介绍其原理、流程、优势、局限性以及示例。

TDD 基于 “测试先行” 的理念，开发者首先明确需求并将其转化为具体的测试用例。

由于此时还未编写实现代码，测试用例必然会失败（呈现 “红色” 状态）。

接着，开发者编写最少的代码使测试用例通过（达到 “绿色” 状态）。

最后，对代码进行重构，在不改变代码外部行为的前提下优化其内部结构，提高代码的可读性、可维护性和可扩展性。

实践：使用Unity测试框架。

Unity 是一个轻量级的测试框架，它使用 C 语言实现， 代码本身很小 。其代码中大多数是宏定义，所以实际编译后的代码会更小， 比较适合在嵌入式测试应用。

Unity的使用之前也有简单分享过：

首先，把Unity源码目录下的unity.c、unity.h、unity_internals.h三个文件复制至我们的工程目录下，并把unity.c添加到我们的keil工程中，然后添加文件路径：

我们打开unity_internals.h文件，发现其有包含一个头文件unity_config.h：

这个文件是配置文件，我们与平台相关的特性放在这个文件中。而这个文件Unity源码中并未提供，所以需要我们自己建立，我这边新建的unity_config.h文件的内容如下：

主要在这里面放了硬件相关的头文件包含以及两个必要的宏定义。第一个宏定义用于重定向输出至串口，第二个宏定义就是我们的串口初始化。

在unity_internals.h中我们发现unity_config.h文件被条件编译屏蔽掉了，我们需要定义宏把它打开：

最后在我们的main.c中包含头文件unity.h即可使用unity测试框架。在unity_internals.h中有很多可修改的配置，比如在不同的平台中，整数的长度是不一样的，在 Unity 中，允许开发者设置整数的长度。如果没有设置， Unity 指定的默认值是 32 位。我们的STM32就是32位的，所以我们不需要修改。

下面开始编写测试用例。 在 Unity 中，每个测试用例是一个函数， 该函数没有参数和返回值。下面我们来测试一个闰年判断函数：

在测试函数中用到 TEST_ASSERT_TRUE 和 TEST_ASSERT_FALSE ， 是 Unity 实现的两个断言， 用于判断 布尔型表达式的值为真或为假。这些测试框架一般都是用断言来进行测试的，包括以上分享的几个框架都是如此。本例中只用到了两个断言，在 Unity 中还有很多断言，如下是部分断言列举：

Unity 默认需要实现用例初始化函数 setUp 和用例清理函数 tearDown，这两个函数均没有参数和返回值。 在闰年判断函数的测试用例中，由于不需要初始化和清理操作，实现的两个函数如下：

在编写了测试用例后， 接下来就可以在 main 函数中运行测试用例。在 Unity 中，使用宏 RUN_TEST 运行测试用例，参数为要运行的测试用例的函数名称。主函数如下：

UNITY_BEGIN函数就是UNITY初始化函数，我们的串口初始化也是在这里面被调用的：

RUN_TEST函数用于运行我们的测试用例。UNITY_END函数就是返回我们的测试结果。最终，运行得到如下结果：

假如，我们把测试闰年的测试函数里的2000改为2001：

那么输出结果就变为：

可以从结果看出没有通过的用例相关的代码所在行。在进行这样子的测试之前，我们当然得要明白我们的功能函数的功能及其预期输出，我们才能去进行测试用例的设计及进行测试。

相关书籍：《测试驱动的嵌入式C语言开发》

三、防御性编程

防御性编程是一种编程范式，旨在通过预见代码中可能出现的错误、异常输入或未定义行为，提前设计保护措施，确保程序在非预期情况下仍能稳定运行、优雅降级或清晰报错，而非崩溃或产生不可控后果。

1. 核心原则

• 不信任任何输入：假设所有输入（包括函数参数、用户输入、外部接口数据等）都是不可信的，必须经过验证。
• 最小化潜在危害：通过隔离风险代码、限制作用域等方式，避免局部错误扩散至整个系统。
• 清晰的错误反馈：错误发生时，提供明确的错误信息或日志，便于调试定位。
• 优雅降级：无法处理错误时，让系统进入安全状态。

2. 最佳实践

（1） 参数校验

函数入口参数合法性检查：

float safe_sqrt(float x) {
    if (x < 0) {
        return NAN;  // 或触发错误处理
    }
    return sqrt(x);
}

（2）断言（Assert）

验证 “不可能发生” 的假设 ，辅助调试：

#include <assert.h>

void memcpy_safe(void* dst, size_t dst_size, const void* src, size_t src_size) 
{
    assert(dst != NULL && src != NULL);  // 指针非空
    assert(dst_size >= src_size);       // 目标空间足够
    // 实际复制逻辑
}

（3）错误码与错误处理

函数通过返回值或输出参数传递错误状态：

enum error_code {
    SUCCESS = 0,
    ERR_INVALID_PARAM,
    ERR_OUT_OF_MEM
};

enum error_code init_device(struct device* dev) {
    if (dev == NULL) return ERR_INVALID_PARAM;
    if (allocate_memory(dev) != 0) return ERR_OUT_OF_MEM;
    return SUCCESS;
}

（4）防御未定义行为

确保整数除法不溢出：

int divide_safe(int a, int b) {
    if (b == 0) return INT_MAX;  // 或触发错误
    if (a == INT_MIN && b == -1) return INT_MAX;  // 处理-2147483648 / -1溢出
    return a / b;
}

防止空指针解引用:

void print_string(const char* str) {
    if (str == NULL) {
        printf("(null)\n");
        return;
    }
    printf("%s\n", str);
}

3.防御性测试优缺点

四、敏捷开发

敏捷开发强调快速迭代、客户反馈和团队协作。在嵌入式开发中，可将项目拆分成多个小的迭代周期，每个周期都有可运行的版本。

1.迭代开发与持续集成

• 短周期迭代：将项目划分为多个短周期迭代，每个迭代通常为 1 - 4 周。在每个迭代中，团队完成一定数量的用户故事，交付可运行的产品增量。短周期迭代有助于快速验证需求和设计，及时调整项目方向。
• 持续集成：建立自动化的持续集成环境，每次代码提交后自动进行编译、测试和集成。在嵌入式开发中，还需进行硬件集成测试，确保软件和硬件的兼容性。持续集成能及时发现代码冲突和缺陷，提高代码质量。
• 迭代评审与回顾：每个迭代结束后，进行迭代评审会议，向客户和相关利益者展示迭代成果，收集反馈意见。同时，召开迭代回顾会议，团队成员总结本次迭代的经验教训，提出改进措施，应用于下一次迭代。

五、瀑布模型

瀑布模型是一种传统的软件开发模型，按照线性顺序依次进行需求分析、设计、编码、测试、维护等阶段，如同瀑布流水一样，每个阶段完成后才进入下一阶段。

瀑布模型作为一种经典的软件开发方法，在嵌入式开发等众多领域具有显著的优势。

1.阶段明确、顺序清晰

瀑布模型的各个阶段界限分明，从需求分析、设计、编码、测试到维护，按照固定的线性顺序依次推进。

这种清晰的阶段划分使得项目流程易于理解和管理，每个阶段都有明确的输入和输出，便于项目团队成员明确各自的职责和任务。

2.强调文档化

该模型非常重视文档的编写和管理，在每个阶段都会产生相应的文档，如需求规格说明书、设计文档、测试报告等。

这些文档不仅是项目各个阶段的重要成果，也是项目团队成员之间沟通的重要工具，同时还为项目的维护和升级提供了有力的支持。

3.易于控制和管理

由于瀑布模型的线性顺序和明确的阶段划分，项目管理者可以很容易地对项目进行监控和控制。

每个阶段都有明确的里程碑和交付物，管理者可以根据这些里程碑来评估项目的进度和质量，及时发现问题并采取相应的措施进行调整。

例如，在编码阶段结束后，可以通过代码审查和单元测试来评估代码的质量，如果发现问题，可以及时反馈给开发人员进行修改。

已上就是本次的分享，如果觉得文章有帮助，麻烦帮忙转发，谢谢！