代码重构在嵌入式开发中的操作方法

TENET-

于 2024-08-14 17:21:17 发布

阅读量464

点赞数 14

分类专栏：嵌入式文章标签：重构

本文链接：https://blog.csdn.net/TENET123/article/details/141195361

版权

嵌入式专栏收录该内容

6 篇文章 4 订阅

订阅专栏

文章目录

1. 代码重构

在嵌入式系统开发中，代码重构通常是一个重要的过程。与其他软件开发领域一样，嵌入式开发也需要代码重构来提高代码的可维护性、可读性和效率。然而，嵌入式系统的独特性（如资源受限、实时性要求、硬件依赖等）使得重构过程更加复杂和关键。

代码质量的提升

随着项目的推进，嵌入式系统的代码往往会变得越来越复杂。为了在严格的时间和资源限制下快速实现功能，开发者可能会编写出“快速且脏”的代码。这些代码虽然短期内能够工作，但从长远来看会增加维护成本并降低系统的稳定性。通过代码重构，可以消除这些潜在的技术债务，提升代码的质量。

适应需求变化

嵌入式系统的需求往往会随着时间而变化。早期的设计和实现可能不再适用于新的需求场景。通过重构，可以对代码进行必要的调整，使其更容易适应新的需求，同时保证系统的稳定性和性能。

资源优化

嵌入式系统通常面临着内存、处理能力和功耗等方面的严格限制。通过重构代码，可以优化资源的使用，减少不必要的开销，提升系统的效率。

2. 常见方法

减少重复代码

在嵌入式开发中，资源是非常宝贵的。重复代码不仅增加了代码的冗余，还使得维护变得复杂。如果一处代码需要修改，所有重复的部分都需要同步更改，这容易导致错误和遗漏。减少重复代码的重构可以使代码更加简洁，减少出错的机会。

步骤：

识别重复代码： 首先，查找代码中重复的部分。通常在不同的函数或文件中可能存在相似的逻辑。
提取公用逻辑： 将重复代码提取为一个独立的函数或模块。确保提取的逻辑是独立的，并且可以通用地应用于不同场景。
替换原始代码： 使用新提取的函数或模块替换原始的重复代码部分。

// 重构前：重复的代码
if (sensor1_read() > THRESHOLD) {
    trigger_alarm();
}

if (sensor2_read() > THRESHOLD) {
    trigger_alarm();
}


// 重构后：提取为通用函数
void check_sensor(int (*sensor_read)()) {
    if (sensor_read() > THRESHOLD) {
        trigger_alarm();
    }
}

check_sensor(sensor1_read);
check_sensor(sensor2_read);

简化条件语句

复杂的条件语句不仅难以理解，还容易导致逻辑错误。通过简化条件语句，可以使代码更加清晰，减少维护和调试的难度。

步骤：

分析条件表达式： 识别复杂条件表达式中冗余或可以简化的部分。
分解复杂逻辑： 将复杂的条件分解成多个简单的条件表达式。使用辅助变量或函数来分离不同的逻辑分支。
使用状态机（如适用）： 如果条件逻辑过于复杂，考虑使用状态机来管理状态转移，简化条件判断。

// 重构前：复杂的条件语句
if (status == STATUS_OK && (mode == MODE_AUTO || (mode == MODE_MANUAL && user_override))) {
    // 执行动作
}

// 重构后：使用状态机简化逻辑
switch (mode) {
    case MODE_AUTO:
        if (status == STATUS_OK) {
            // 执行动作
        }
        break;
    case MODE_MANUAL:
        if (status == STATUS_OK && user_override) {
            // 执行动作
        }
        break;
}

注意：在嵌入式系统中，过多的条件分支可能会增加代码的复杂性和执行时间。应确保简化后的逻辑能够高效执行，并且不会影响系统的实时性。

消除魔法数和硬编码值

魔法数是指代码中直接使用的数字常量，这些常量往往难以理解且易于出错。通过将魔法数替换为具名常量或枚举，可以提高代码的可读性和可维护性。

步骤：

识别魔法数： 查找代码中直接使用的数字常量，尤其是那些在多个地方使用的常量。
引入具名常量或枚举： 使用#define宏、const变量或enum枚举来定义这些常量。
替换魔法数： 将代码中使用的魔法数替换为具名常量。

// 重构前：使用魔法数
if (timer_count >= 1000) {
    // 处理超时
}

// 重构后：使用具名常量
#define TIMEOUT_THRESHOLD 1000
if (timer_count >= TIMEOUT_THRESHOLD) {
    // 处理超时
}

同样要注意：定义的常量应当考虑内存和性能的影响。如果可能，使用const代替#define，以获得更好的类型检查和调试支持。

封装硬件访问

嵌入式系统通常直接访问硬件寄存器或使用特定的硬件API。直接访问硬件虽然效率高，但也使得代码的移植性和可维护性降低。通过封装硬件访问，可以将硬件依赖部分与应用逻辑分离，提升代码的灵活性。

步骤：

识别硬件访问代码： 找出代码中直接操作硬件寄存器或调用硬件相关API的部分。
创建硬件抽象层： 使用函数、类或模块封装这些硬件访问操作。
替换直接访问： 将原本直接的硬件访问替换为调用封装好的接口。

// 重构前：直接访问硬件寄存器
volatile uint8_t *reg = (uint8_t *)0xFF00;
*reg = 0x01;

// 重构后：封装硬件访问
void set_register(uint8_t value) {
    volatile uint8_t *reg = (uint8_t *)0xFF00;
    *reg = value;
}

set_register(0x01);

提取函数

长函数往往包含多种逻辑和处理步骤，使得代码难以理解和维护。通过将这些逻辑提取到独立的函数中，可以使代码更加模块化、易读，同时也便于复用。

步骤：

识别逻辑块： 找出长函数中独立的逻辑块，这些块应具备独立的功能。
提取为函数： 将识别出的逻辑块提取为一个或多个独立的函数。
替换原始代码： 使用新提取的函数替换原始代码块，使主函数更加简洁。

// 重构前：一个长函数，包含多个逻辑
void process_data() {
    // 读取数据
    int data = read_sensor();

    // 数据处理
    if (data > THRESHOLD) {
        // 触发报警
        trigger_alarm();
    }

    // 显示结果
    display_result(data);
}

// 重构后：提取为多个函数
void process_data() {
    int data = read_sensor();
    handle_data(data);
    display_result(data);
}

void handle_data(int data) {
    if (data > THRESHOLD) {
        trigger_alarm();
    }
}

3. 重构的特殊考虑

在嵌入式系统中进行代码重构时，与其他类型的软件开发相比，需要考虑一些独特的挑战。这些特殊考虑主要集中在性能、资源限制、测试验证以及硬件依赖性方面。以下是详细的解释：

性能与实时性

嵌入式系统通常对性能和实时性有非常严格的要求。任何增加的代码复杂度或函数调用，都会对系统的响应时间产生影响。尤其是在硬实时系统中，延迟可能导致系统无法按预期工作，甚至引发严重的安全问题。

解决方案： 在重构过程中，必须确保新代码不会引入额外的延迟或资源消耗。例如，在性能敏感的代码路径中，应尽量减少不必要的函数调用和复杂的逻辑判断。可以通过以下方法来验证性能和实时性：

性能分析工具： 使用性能分析工具来检测重构前后的性能变化。
基准测试： 对关键路径进行基准测试，确保重构后系统的响应时间不超过预定阈值。
代码审查： 在代码审查过程中，特别关注性能和实时性，确保重构不会引入性能瓶颈。

如果在重构中需要引入新的抽象层或模块化设计，应先进行小范围的测试，确认是否存在性能下降。如果存在性能问题，可能需要重新评估是否进行这种重构。

资源限制

嵌入式设备通常具有非常有限的内存、处理能力和存储空间。任何增加的代码复杂性或内存使用都可能超出系统的资源限制，从而导致系统无法正常运行。

解决方案： 在重构时，必须严格控制内存和存储的使用，避免不必要的内存分配和代码膨胀。可以通过以下方法来管理资源限制：

静态代码分析： 使用静态分析工具评估内存使用和代码大小，确保不超过系统的资源限制。
内存优化技术： 采用内存优化技术，如使用更紧凑的数据结构、减少动态内存分配，以及避免内存碎片。
分段重构： 将重构分成多个小步骤，逐步改进代码结构，每次重构后进行资源使用的评估，确保不会超出设备的资源限制。

在重构中，如果需要引入新的数据结构或缓存机制，应先评估其对内存和存储的影响。如果发现资源使用接近设备的上限，可能需要回退重构或者采取其他优化措施。

测试与验证

嵌入式系统通常与特定硬件紧密耦合，代码的任何改动都可能影响系统的整体行为。因此，重构后的代码必须经过严格的测试和验证，确保系统功能和性能不受影响。

解决方案： 在重构过程中，需要建立完善的测试体系，包括单元测试、集成测试和硬件在环测试，以确保代码的正确性。以下是一些关键方法：

自动化测试： 使用自动化测试框架来覆盖重构后的代码，确保功能的一致性。
硬件在环测试（HIL）： 在真实的硬件环境中测试重构后的代码，确保与硬件的交互正常。
回归测试： 通过回归测试验证重构后的代码是否对现有功能产生了负面影响。

在重构涉及到硬件接口的代码时，特别需要在实际硬件上进行测试，而不仅仅依赖于仿真或模拟环境。这有助于捕获硬件相关的潜在问题，如时序问题或信号完整性问题。

硬件依赖性

嵌入式系统的代码通常直接与硬件交互，因此在重构过程中需要格外小心，避免引入影响硬件操作的变更。此外，不同的硬件平台可能具有不同的要求和限制，这使得代码的移植性成为一个关键问题。

解决方案： 在重构时，可以通过引入硬件抽象层（HAL）来隔离硬件依赖的部分。这样可以提高代码的可移植性，同时确保在不同硬件平台上保持一致的行为。具体措施包括：

硬件抽象层（HAL）： 将与硬件相关的代码封装到HAL中，使应用层代码独立于具体硬件。
模块化设计： 通过模块化设计将硬件依赖部分与应用逻辑分离，便于在不同平台上移植。
平台验证： 在不同的硬件平台上进行验证测试，确保代码的可移植性和兼容性。

在重构涉及到寄存器访问或外设操作的代码时，可以将这些操作封装到HAL函数中。这样，在更换硬件平台时，只需修改HAL的实现，而不需要更改应用层代码。

4. 代码重构的最佳实践

在嵌入式软件开发中，代码重构是有助于提升代码的质量和可维护性。然而，由于嵌入式系统的特殊性，重构过程需要更加谨慎。为了确保重构成功且不影响系统的稳定性和性能，遵循一些规则是非常重要的。

小步快跑，渐进式重构

重构应该以小步骤进行，每次只对代码进行一个小的改动。这种渐进式的重构方式使得开发人员可以在每次重构后立即测试和验证，确保系统功能和性能保持不变。

降低风险： 小步快跑使得每次改动都可以轻松回滚，减少了大范围改动带来的风险。
易于调试： 当问题出现时，可以迅速定位到最近一次的改动，缩短调试时间。

方法：

版本控制： 在进行每个小改动前，都应该使用版本控制系统（如Git）进行提交，并附上详细的注释。
自动化测试： 每次小范围重构后，立即运行自动化测试，确保代码的正确性。

如果你要重构一个复杂的条件语句，可以先将其分解为几个简单的表达式，测试每一个表达式，然后逐步合并到最终的逻辑中。

测试驱动重构

在进行重构之前，首先要确保已有的功能都有相应的测试覆盖。理想情况下，应该采用测试驱动开发（TDD）的方法，先编写测试用例，再进行重构。重构后，运行这些测试用例，确保重构没有引入新的问题。

防止回归： 测试驱动重构能够确保重构后的代码保持原有功能，防止意外的回归问题。
提升信心： 每次重构后通过测试的成功运行，可以给开发者带来信心，确保系统的可靠性。

方法：

编写单元测试： 为每个功能模块编写详细的单元测试，确保代码重构后其行为不变。
增加测试覆盖率： 在重构前，评估测试覆盖率并补充遗漏的测试用例，特别是对关键功能的测试。

如果你正在重构一个负责硬件控制的函数，应先编写详细的测试用例，涵盖所有可能的输入和边界情况，然后在每次小步重构后运行这些测试。

保持代码行为一致

重构的核心原则是保持代码的外部行为不变。这意味着无论如何改动代码内部实现，系统的功能、性能和对外接口都不应该受到影响。

确保稳定性： 通过保持行为一致，避免了功能的意外变化，确保系统的稳定性。
简化测试： 当行为保持一致时，现有的测试用例仍然适用，减少了测试工作量。

方法：

明确重构目标： 在每次重构之前，明确重构的目标是优化代码，而不是改变功能。
回归测试： 重构完成后，运行回归测试，确保系统的行为与预期一致。

在重构涉及到通信协议或数据处理的代码时，特别需要注意保持输入输出接口的行为一致。例如，如果你优化了数据处理算法，应确保其处理速度提升但输出结果不变。

持续重构

重构不应只在系统出现问题时才进行，而应该成为开发过程中的常规部分。通过持续、定期的小规模重构，可以防止技术债务的积累，保持代码的整洁和可维护性。

预防问题： 通过持续重构，及时清理技术债务，避免问题积重难返。
代码健康： 定期的小规模重构可以保持代码库的健康，防止代码腐化和质量下降。

方法：

代码审查： 在代码审查过程中，识别需要重构的部分并立即进行小规模重构。
开发习惯： 将重构作为开发的自然部分，每次提交代码时都考虑是否需要重构。

在开发新功能时，可能会发现与现有代码的某些部分重复或耦合度过高。这时应立即进行重构，而不是等到问题变得更加复杂时再处理。

优先处理关键路径

在嵌入式系统中，关键路径（如实时控制逻辑或性能关键的部分）对系统的整体性能和稳定性至关重要。在重构过程中，优先处理这些关键路径，确保它们的效率和可靠性。

提升系统性能： 优先重构关键路径，可以直接提升系统的性能和响应速度。
减少风险： 对关键路径进行重构，可以尽早发现潜在的性能瓶颈和不稳定因素。

方法：

性能分析： 使用性能分析工具识别关键路径，并优先考虑对这些部分进行重构。
代码优化： 在重构关键路径时，注重性能优化，减少不必要的开销和复杂性。

如果系统的实时性对某些任务至关重要，可以通过重构优化任务调度算法或中断处理例程，减少处理延迟，提高系统响应能力。

5. 重构示例

假设我们有一个简单的嵌入式系统，用于读取多个传感器的数据，并根据这些数据控制一些设备。以下是原始代码的实现，它包含了一些不良的编码实践，比如重复的代码、复杂的条件语句和直接的硬件访问。

#include <stdio.h>

#define SENSOR_COUNT 3
#define THRESHOLD 50

// 模拟传感器读取函数
int sensor_read(int sensor_id) {
    // 模拟读取不同的传感器
    if (sensor_id == 0) return 30;
    if (sensor_id == 1) return 55;
    if (sensor_id == 2) return 45;
    return 0;
}

// 模拟设备控制函数
void device_control(int device_id, int action) {
    printf("Device %d is now %s\n", device_id, action ? "ON" : "OFF");
}

void monitor_sensors_and_control_devices() {
    // 监控第一个传感器
    int sensor_value_0 = sensor_read(0);
    if (sensor_value_0 > THRESHOLD) {
        device_control(0, 1);  // 开启设备0
    } else {
        device_control(0, 0);  // 关闭设备0
    }

    // 监控第二个传感器
    int sensor_value_1 = sensor_read(1);
    if (sensor_value_1 > THRESHOLD) {
        device_control(1, 1);  // 开启设备1
    } else {
        device_control(1, 0);  // 关闭设备1
    }

    // 监控第三个传感器
    int sensor_value_2 = sensor_read(2);
    if (sensor_value_2 > THRESHOLD) {
        device_control(2, 1);  // 开启设备2
    } else {
        device_control(2, 0);  // 关闭设备2
    }
}

int main() {
    monitor_sensors_and_control_devices();
    return 0;
}

问题分析

上述代码存在以下问题：

重复的代码：sensor_read 和 device_control 的调用被重复了多次，增加了代码的冗余度。
魔法数：THRESHOLD 虽然被定义为宏，但硬编码的设备ID和动作在代码中多次出现，不利于维护。
可扩展性差：如果需要增加或减少传感器数量，必须手动修改多处代码，维护成本高。

第一步：提取重复的逻辑

提取监控传感器和控制设备的重复逻辑到一个独立的函数中。

#include <stdio.h>

#define SENSOR_COUNT 3
#define THRESHOLD 50

int sensor_read(int sensor_id) {
    if (sensor_id == 0) return 30;
    if (sensor_id == 1) return 55;
    if (sensor_id == 2) return 45;
    return 0;
}

void device_control(int device_id, int action) {
    printf("Device %d is now %s\n", device_id, action ? "ON" : "OFF");
}

void check_and_control_device(int sensor_id, int device_id) {
    int sensor_value = sensor_read(sensor_id);
    if (sensor_value > THRESHOLD) {
        device_control(device_id, 1);  // 开启设备
    } else {
        device_control(device_id, 0);  // 关闭设备
    }
}

void monitor_sensors_and_control_devices() {
    for (int i = 0; i < SENSOR_COUNT; i++) {
        check_and_control_device(i, i);
    }
}

int main() {
    monitor_sensors_and_control_devices();
    return 0;
}

第二步：消除魔法数并改进可扩展性

接下来可以通过使用结构体和配置数组的方式来进一步减少硬编码的魔法数，并增强代码的可扩展性。

#include <stdio.h>

#define SENSOR_COUNT 3
#define THRESHOLD 50

typedef struct {
    int sensor_id;
    int device_id;
} SensorDeviceMapping;

SensorDeviceMapping mappings[SENSOR_COUNT] = {
    {0, 0},
    {1, 1},
    {2, 2}
};

int sensor_read(int sensor_id) {
    if (sensor_id == 0) return 30;
    if (sensor_id == 1) return 55;
    if (sensor_id == 2) return 45;
    return 0;
}

void device_control(int device_id, int action) {
    printf("Device %d is now %s\n", device_id, action ? "ON" : "OFF");
}

void check_and_control_device(SensorDeviceMapping mapping) {
    int sensor_value = sensor_read(mapping.sensor_id);
    if (sensor_value > THRESHOLD) {
        device_control(mapping.device_id, 1);  // 开启设备
    } else {
        device_control(mapping.device_id, 0);  // 关闭设备
    }
}

void monitor_sensors_and_control_devices() {
    for (int i = 0; i < SENSOR_COUNT; i++) {
        check_and_control_device(mappings[i]);
    }
}

int main() {
    monitor_sensors_and_control_devices();
    return 0;
}

第三步：优化结构

还可以将配置和逻辑分离，进一步提升代码的灵活性和可维护性。假设我们可能会在未来支持不同的传感器类型和设备控制策略，可以将这些信息存储在配置中。

#include <stdio.h>

#define SENSOR_COUNT 3
#define THRESHOLD 50

typedef struct {
    int sensor_id;
    int (*read_func)(int sensor_id);
    int device_id;
    void (*control_func)(int device_id, int action);
} SensorDeviceMapping;

int sensor_read(int sensor_id) {
    if (sensor_id == 0) return 30;
    if (sensor_id == 1) return 55;
    if (sensor_id == 2) return 45;
    return 0;
}

void device_control(int device_id, int action) {
    printf("Device %d is now %s\n", device_id, action ? "ON" : "OFF");
}

SensorDeviceMapping mappings[SENSOR_COUNT] = {
    {0, sensor_read, 0, device_control},
    {1, sensor_read, 1, device_control},
    {2, sensor_read, 2, device_control}
};

void check_and_control_device(SensorDeviceMapping mapping) {
    int sensor_value = mapping.read_func(mapping.sensor_id);
    if (sensor_value > THRESHOLD) {
        mapping.control_func(mapping.device_id, 1);  // 开启设备
    } else {
        mapping.control_func(mapping.device_id, 0);  // 关闭设备
    }
}

void monitor_sensors_and_control_devices() {
    for (int i = 0; i < SENSOR_COUNT; i++) {
        check_and_control_device(mappings[i]);
    }
}

int main() {
    monitor_sensors_and_control_devices();
    return 0;
}

这个重构示例展示了如何从一个功能正常但结构复杂的C代码开始，通过一系列的重构步骤，将代码转化为更简洁、易于理解、维护和扩展的版本。

TENET-

关注

14
点赞
踩
6

收藏

觉得还不错? 一键收藏
打赏
0
评论
代码重构在嵌入式开发中的操作方法

在嵌入式系统开发中，代码重构通常是一个重要的过程。与其他软件开发领域一样，嵌入式开发也需要代码重构来提高代码的可维护性、可读性和效率。然而，嵌入式系统的独特性（如资源受限、实时性要求、硬件依赖等）使得重构过程更加复杂和关键。
复制链接

扫一扫