1. 项目概述：为什么嵌入式工程师必须懂排序？

在嵌入式开发这个行当里，一提到“算法”，很多人的第一反应可能是复杂的图像处理、机器学习或者通信协议。但在我十多年的项目经历里，真正决定一个嵌入式系统是否“丝滑”、是否“稳定”的，往往是一些最基础的算法，其中 排序算法 就是典型代表。你可能觉得排序是计算机科学101的内容，有什么好讲的？但恰恰是这种基础，在资源受限的MCU（微控制器）上，其选择和实现直接关系到系统的实时性、功耗和内存占用。

这个项目标题“嵌入式算法12---排序算法”，其核心价值在于将经典的排序算法从PC的“舒适区”拉到嵌入式这个“战场”上。它不是简单地复述冒泡排序、快速排序的原理，而是要解决一个嵌入式工程师每天都会面临的灵魂拷问：在只有几十KB RAM、主频几十MHz的芯片上，面对传感器采集的几百个数据点，我该用哪种排序方法？是追求极致的速度，还是优先保证最坏情况下的响应时间？又或者，我的数据是否已经“基本有序”，可以用更取巧的办法？

这篇文章，就是为你拆解在嵌入式场景下，排序算法从选型、优化到实战落地的全过程。我会结合真实的项目案例，比如用STM32处理陀螺仪数据、用ESP32整理Wi-Fi信号强度列表，来告诉你不同排序算法的“脾气”，以及如何根据你的硬件资源和数据特性，做出最“经济”的选择。无论你是刚接触嵌入式的学生，还是正在为产品性能优化头疼的工程师，相信这些从坑里爬出来的经验，都能给你带来直接的帮助。

2. 嵌入式排序算法的核心设计思路

在通用计算机上，我们讨论排序算法，通常只关心平均时间复杂度，O(n log n)就是好算法。但在嵌入式世界，这个评价体系被彻底颠覆了。这里没有“银弹”，只有“权衡”。我们的设计思路必须围绕三个核心约束展开： 有限的资源 、 确定的实时性 和 特定的数据特征 。

2.1 资源约束是第一设计原则

嵌入式系统的资源是“抠”着用的。每一次内存分配、每一个CPU周期都要精打细算。

  1. 空间复杂度优先于时间复杂度 ：在PC上，我们可能毫不犹豫选择归并排序（O(n log n)时间， O(n)空间）。但在只有10KB空闲RAM的MCU上，对一个包含1000个整型（4KB）的数组进行排序，归并排序需要的额外4KB空间可能就是不可承受之重。此时，原地排序算法（如堆排序、快速排序的某些变种）虽然可能稍慢，但因其O(1)的额外空间消耗而成为首选。
  2. 缓存友好性 ：现代高性能MCU（如Cortex-M7）也有缓存。算法的内存访问模式是否连续，对性能影响巨大。例如， 插入排序 对数据的访问是顺序的，缓存命中率高；而 快速排序 在递归过程中的跳跃式访问，可能导致较多的缓存缺失。在处理中等规模数据时，缓存效应可能比理论时间复杂度更重要。
  3. 代码体积（Flash占用） ：算法实现本身的代码量也需要考虑。一个复杂的 希尔排序 或 快速排序 的递归实现，其代码量可能比简单的 冒泡排序 大好几KB。在Flash空间紧张的廉价MCU上，这可能直接决定你的固件能否装得下。

2.2 实时性与确定性分析

嵌入式系统很多是实时系统，要求任务在确定的时间内完成。

  1. 最坏情况时间复杂度 ：这是实时系统的命门。快速排序的平均性能是O(n log n)，但其最坏情况（如数组已有序）会退化到O(n²)。如果你的系统必须保证在任何输入下，排序操作都在10ms内完成，那么快速排序就不是一个安全的选择。 堆排序 虽然平均性能可能略低于快排，但其最坏情况也是O(n log n)，提供了确定性的性能上界。
  2. 是否可中断 ：有些排序算法，如选择排序，在执行过程中有明确的“阶段”。在完成第i个元素的放置后，算法状态是清晰的，理论上可以被中断，稍后恢复。而像快速排序这样的递归算法，中断和恢复其状态（调用栈）就非常复杂。这在需要响应高优先级中断的系统中是一个重要考量。

2.3 数据特征决定算法选择

嵌入式系统的数据往往有鲜明的特点，利用好这些特点可以极大提升效率。

  1. 数据规模小 ：这是最常见的情况。传感器采样缓冲区、通信协议的命令队列、显示设备的刷新列表，其数据量通常在几十到几百个元素。当n很小时，O(n²)和O(n log n)的差距可能微乎其微。此时， 插入排序 或 选择排序 这类简单算法，因其极低的常数因子和代码复杂度，反而可能是最快的。
  2. 数据基本有序 ：很多嵌入式应用的数据流是“渐进变化”的。例如，温度监测值在短时间内不会突变。对新采集到的少量无序数据，插入排序的效率接近O(n)，因为它只需要将少数元素移动到正确位置。这是 自适应排序算法 大显身手的地方。
  3. 数据类型简单 ：嵌入式系统大量处理的是整数、定点数或简单的结构体。这意味着比较操作和交换操作的成本很低。复杂的、需要大量动态内存分配或深拷贝的排序场景较少，这简化了算法实现。

基于以上思路，我们可以形成一个初步的选型决策树：先看数据量，再看资源，最后考虑数据特性。但这只是开始，接下来我们要深入每种算法的嵌入式实现细节。

3. 核心算法解析与嵌入式适配要点

我们将几种经典排序算法放在嵌入式显微镜下，逐一分析其优劣及改造方法。

3.1 冒泡排序：不仅仅是教学工具

尽管背负着O(n²)的“恶名”，冒泡排序在嵌入式领域并未完全退场。

嵌入式价值 ：

  • 实现极其简单 ：代码不超过10行，几乎无Bug，占用Flash极小。适合在Bootloader等对空间有极致要求的环境下，对极小规模（如n<10）配置数据进行排序。
  • 检测有序性 ：通过加入 flag 检测本轮是否发生交换，可以在数据已经有序时提前终止，此时时间复杂度为O(n)。对于近乎有序的实时数据流，这是一个轻量级的排序兼校验手段。

嵌入式优化与注意事项 ：

注意：经典的冒泡排序每次循环都会比较所有相邻元素。一个实用的优化是记录最后一次交换的位置，下一轮循环只进行到这个位置为止，因为之后的元素已经处于最终位置。

// 优化后的冒泡排序（C语言示例）
void bubble_sort_optimized(int arr[], int n) {
    int i, j;
    int new_n; // 记录每趟扫描的边界
    for (i = 0; i < n-1; i++) {
        new_n = 0; // 假设本次无交换
        for (j = 0; j < n-1-i; j++) { // 经典写法是 j < n-1-i
            // 更优的边界是上一轮最后交换的位置
            // 这里简化为经典写法，但思想要明确
            if (arr[j] > arr[j+1]) {
                swap(&arr[j], &arr[j+1]);
                new_n = j+1; // 记录最后一次交换的位置
            }
        }
        // 如果new_n为0，说明本轮无交换，已完全有序
        // 可以将n-i-1更新为new_n，进一步减少循环。此处为示意。
        if (new_n == 0) break;
    }
}

实操心得 ：在资源极度紧张且数据量极小的场合（如8位MCU排序5个键值），别嫌弃冒泡排序。它的简单性就是最大的可靠性。但务必加上提前终止的优化，这是从O(n²)到O(n)的关键一步。

3.2 插入排序：嵌入式系统的“隐藏冠军”

插入排序是我在嵌入式项目中使用频率最高的排序算法，没有之一。

嵌入式价值 ：

  • 对小规模和基本有序数据效率极高 ：在数据量小于50时，其性能常常优于更复杂的算法。对于实时采集的、基本有序的数据流（如ADC采样值），插入新元素并保持数组有序的操作接近O(1)。
  • 原地、稳定且缓存友好 ：顺序访问内存，对缓存非常友好。代码实现同样简单。
  • 在线排序（Online Sorting） ：它非常适合“来一个数据，插入一个数据”的场景，无需等待所有数据到齐再排序，可以边采集边维护有序序列，减少整体延迟。

嵌入式实现技巧 ：

// 标准的插入排序
void insertion_sort(int arr[], int n) {
    int i, j, key;
    for (i = 1; i < n; i++) {
        key = arr[i];
        j = i - 1;
        // 将大于key的元素向后移动
        while (j >= 0 && arr[j] > key) {
            arr[j + 1] = arr[j];
            j--;
        }
        arr[j + 1] = key;
    }
}

一个高级技巧：二分插入排序 。在寻找插入位置时，对于已排序的部分使用二分查找，可以将比较次数从O(n²)降到O(n log n)，但移动次数不变。当比较操作成本很高时（比如排序的是字符串或复杂结构体），这个优化很有价值。

实操心得 ：当你需要维护一个实时更新的小型排行榜（如最高10个温度值）、或对通信缓冲区进行排序时，首先考虑插入排序。它的性能表现往往超出你的预期。

3.3 快速排序：性能与风险的平衡

快速排序是通用排序的王者，但在嵌入式领域，必须“戴着镣铐跳舞”。

嵌入式风险 ：

  • 递归导致的栈溢出 ：递归实现简洁，但在深度递归时可能耗尽MCU有限的栈空间，导致系统崩溃。
  • 最坏情况性能退化 ：在已排序或逆序数组上，如果基准（pivot）选择不当（如总是选第一个元素），会退化为O(n²)，这对于实时系统是灾难。
  • 非稳定排序 ：在某些需要保持相同元素相对顺序的场景下，这可能是个问题。

嵌入式安全改造方案 ：

  1. 迭代替代递归 ：使用显式栈来模拟递归过程，避免栈溢出风险，并能精确控制内存使用。 
    // 使用自定义栈的迭代快速排序框架
#define MAX_STACK_SIZE 100
typedef struct {
    int low;
    int high;
} StackItem;

void quick_sort_iterative(int arr[], int low, int high) {
    StackItem stack[MAX_STACK_SIZE];
    int top = -1;
    stack[++top] = (StackItem){low, high};

    while (top >= 0) {
        StackItem item = stack[top--];
        low = item.low;
        high = item.high;

        if (low < high) {
            int pi = partition(arr, low, high); // 划分函数
            // 压入较大的子数组先处理，控制栈深度
            if (pi - low > high - pi) {
                stack[++top] = (StackItem){low, pi - 1};
                stack[++top] = (StackItem){pi + 1, high};
            } else {
                stack[++top] = (StackItem){pi + 1, high};
                stack[++top] = (StackItem){low, pi - 1};
            }
        }
    }
}
  2. “三数取中”法选择基准 ：选取数组头、尾、中间三个元素的中位数作为基准，能有效避免对已排序数组的最坏情况。
  3. 小数组切换为插入排序 ：当递归或迭代到子数组规模很小（如n < 16）时，直接调用插入排序。因为插入排序在小数据量上常数因子更小，且能避免快速排序递归调用的开销。这是工业级排序库（如C标准库的qsort）的通用优化。

实操心得 ：在STM32F4等拥有足够RAM（几十KB以上）和主频（>100MHz）的平台上，处理上千个数据点的排序，改造后的快速排序是首选。但务必实现“三数取中”和“小数组切换”这两个优化，这是工程可用性的底线。

3.4 堆排序：实时系统的“定心丸”

堆排序像是嵌入式领域的“三好学生”：原地排序（O(1)空间）、最坏情况O(n log n)、非递归。但它也有缺点：缓存不友好（跳跃访问）、平均常数因子比快排大。

嵌入式价值 ：

  • 确定性 ：最大的优点。无论输入数据如何分布，它都能保证O(n log n)的时间复杂度。这对于有严格最坏响应时间要求（WCET, Worst-Case Execution Time）的硬实时系统至关重要。
  • 不需要额外空间 ：适合内存极其拮据的场合。
  • 获取Top-K元素的利器 ：如果你只需要最大的K个元素（如寻找10个最强的Wi-Fi信号），你可以维护一个大小为K的最小堆，扫描一遍数据即可得到结果，时间复杂度O(n log K)，空间复杂度O(K)，非常高效。

嵌入式实现注意点 ： 堆排序的构建堆（heapify）和调整堆（sift-down）过程涉及大量的父子节点索引计算（ parent = (i-1)/2 , left = 2*i+1 ）。确保使用位操作进行优化（例如，对于下标从0开始的堆， left_child = (i << 1) + 1 ），并在频繁调用的排序场景中，考虑将比较和交换操作封装成宏或内联函数以减少函数调用开销。

实操心得 ：当你的产品需要通过功能安全认证，或者排序操作的响应时间必须有一个绝对可靠的上限时，堆排序是你的安全牌。虽然它可能不是最快的，但一定是最 predictable 的。

3.5 选择排序与希尔排序：特定场景的利器

  • 选择排序 ：每次选最小（大）值。其交换次数是确定的O(n)，在所有排序算法中最少。如果交换数据的成本极高（例如，排序的不是整数，而是存储在外部Flash中、需要擦写的大块数据），选择排序可能比插入排序更有优势。但在嵌入式内部RAM排序中，它通常不如插入排序。
  • 希尔排序 ：插入排序的改进版，通过比较相距一定间隔的元素来工作，逐步缩小间隔。它是原地排序，且代码量不大。对于中等规模（几百个）且无明显特征的数据，希尔排序的性能表现非常均衡，且没有快速排序的退化风险。你可以将它视为在简单性和高性能之间一个不错的折中选项。

4. 嵌入式排序实战：从选型到集成

理论说再多，不如看实战。我们假设两个典型的嵌入式场景。

4.1 场景一：实时传感器数据的中值滤波

需求 ：基于STM32G0（Cortex-M0+， 64KB Flash， 20KB RAM）采集一路模拟温度传感器数据，采样率100Hz。为了抑制脉冲噪声，需要对最近20个采样值进行排序，取中位数作为当前有效值。

分析与选型 ：

  1. 数据规模 ：n=20， 很小。
  2. 数据特性 ：连续采样值，高度相关，基本有序。
  3. 资源限制 ：RAM有限，需节省每一个Byte。
  4. 实时性 ：每10ms需要完成一次排序，时间预算充足。

方案 ：采用 插入排序 。

  • 理由 ：数据基本有序，插入排序在这种情况下效率接近O(n)。每次新采样值到来，我们将其放入数组末尾（覆盖最旧的值），然后对整个20个元素的数组执行一次插入排序。由于数组近乎有序，排序过程很快。
  • 优化 ：维护一个循环缓冲区，每次只需对新插入的元素调用一次插入例程（即只做一轮插入排序的“插入”步骤），即可保持整个数组有序，将计算量降到最低。
  • 代码示意 ： 
    #define WINDOW_SIZE 20
int sensor_buffer[WINDOW_SIZE];
int buffer_index = 0;

void update_and_filter(int new_sample) {
    // 1. 新数据覆盖旧数据
    sensor_buffer[buffer_index] = new_sample;
    buffer_index = (buffer_index + 1) % WINDOW_SIZE;

    // 2. 单次插入排序（仅对新元素进行插入）
    int key = new_sample;
    int j = (buffer_index - 2 + WINDOW_SIZE) % WINDOW_SIZE; // 从新元素前一个位置开始
    // 注意：这里需要在循环数组中找到正确的插入位置，逻辑稍复杂，但原理不变。
    // 简化起见，也可以每次都对整个数组排序，因为n=20，开销也可接受。
    // 以下是整个数组排序的简单实现：
    insertion_sort(sensor_buffer, WINDOW_SIZE);

    // 3. 取中位数
    int median = sensor_buffer[WINDOW_SIZE / 2];
    // 使用median...
}

4.2 场景二：智能家居网关的信号强度排行榜

需求 ：基于ESP32（双核， 520KB RAM）的智能家居网关，需要扫描周围Wi-Fi设备，并实时显示信号强度（RSSI）最强的10个设备。扫描列表可能包含50-100个设备，每秒更新一次。

分析与选型 ：

  1. 核心需求 ：获取Top-10，而非完全排序。
  2. 数据规模 ：n在50-100之间，中等。
  3. 资源 ：ESP32资源相对丰富，但排序操作频率高（1Hz），需考虑功耗和效率。

方案 ：采用 基于堆的Partial Sort（部分排序） 。

  • 理由 ：完全排序（O(n log n)）是浪费。我们维护一个大小为10的 最小堆 。初始时，用前10个扫描结果建堆。然后遍历剩余的设备：
    • 如果当前设备的RSSI比堆顶（当前第10强）还弱，忽略。
    • 如果更强，则替换堆顶元素，并重新调整堆（sift-down）。
  • 优势 ：时间复杂度O(n log K)，其中K=10，远低于全排序。空间复杂度O(K)，只需额外存储10个元素的结构体（包含SSID和RSSI）。
  • 代码框架 ： 
    typedef struct {
    char ssid[32];
    int rssi;
} WifiDevice;

WifiDevice top_k_heap[10]; // 最小堆
int heap_size = 0;

// 当扫描到新设备时
void process_new_device(WifiDevice *dev) {
    if (heap_size < 10) {
        // 堆未满，直接插入
        top_k_heap[heap_size] = *dev;
        heap_size++;
        heapify_up(heap_size - 1); // 上浮调整
    } else if (dev->rssi > top_k_heap[0].rssi) {
        // 新设备比当前第10名强，替换堆顶
        top_k_heap[0] = *dev;
        heapify_down(0, heap_size); // 下沉调整
    }
    // 否则，忽略该设备
}
// 遍历结束后，top_k_heap中就是最强的10个设备（但堆顶是最弱的那个）
// 如果需要按强度降序输出，可以对这10个元素进行一次排序（例如插入排序）。

实操心得 ：Top-K问题是嵌入式领域的常客。永远不要一上来就对整个数据集排序。先问自己：“我真的需要全部有序吗？” 答案往往是否定的。基于堆的选择算法是解决这类问题的标准答案。

5. 进阶话题：排序在嵌入式系统中的特殊变体

除了通用排序，嵌入式领域还有一些特殊的“排序”需求。

5.1 计数排序与基数排序：当数据范围已知时

如果待排序的数据是有限范围内的整数（例如，8位ADC的采样值0-255，或灰度图像的像素值）， 计数排序 是O(n)的神器。

  • 原理 ：统计每个值出现的次数，然后按顺序输出。
  • 嵌入式优势 ：速度极快，且是稳定排序。需要额外的计数数组，其大小等于数据范围。如果范围不大（如256），这完全可以接受。
  • 应用场景 ：图像处理中的直方图均衡化、数字滤波前的数据预处理。

基数排序 则是针对多关键字（如32位整数，可看作4个8位关键字）的线性排序。它通过从低位到高位（LSD）或从高位到低位（MSD）进行多次稳定的子排序（通常用计数排序作为子例程）来实现。在需要对大量固定位宽的整数或字符串进行排序时，它可能比基于比较的排序更快，但实现更复杂，且需要O(n)的额外空间。

5.2 外排序：当数据无法全部装入内存

虽然不常见，但在一些数据记录系统中，可能需要处理大于内存的数据集（例如，将大量传感器数据从Flash中读出并排序）。这时需要 外排序 ，通常采用“排序-归并”策略：

  1. 将大数据集分块，每次读入内存一块，用内部排序算法（如快速排序）排序，然后将有序块写回存储。
  2. 使用多路归并算法，将多个有序块合并成最终的有序序列。

这在嵌入式Linux或带文件系统的设备中更有意义，在裸机系统中较少遇到。

5.3 利用硬件特性：DMA与排序

在一些高端MCU或DSP上，可以考虑利用DMA（直接内存访问）来加速数据搬运，从而间接优化排序性能。例如，在归并排序的合并阶段，可以使用DMA来搬运数据块，解放CPU去执行比较操作。但这属于非常极致的优化，需要对硬件和算法有很深的理解，普通项目不必强求。

6. 常见问题、调试技巧与性能实测

6.1 排序结果不正确？从这些地方查起

  1. 数组越界 ：这是最最常见的错误。尤其是在实现快速排序的 partition 函数或堆排序的 sift-down 函数时，循环条件中的 < 和 <= ，或者索引 j 和 j+1 ，稍不留神就会写错。 务必在代码中增加断言（assert） ，检查数组索引是否在有效范围内。 
    #include <assert.h>
int partition(int arr[], int low, int high) {
    assert(low >= 0 && high < ARRAY_SIZE);
    // ... 分区逻辑
}
  2. 递归深度爆炸 ：在快速排序中，如果对重复元素很多或已排序的数组使用最左端作为基准，递归深度会达到n。在MCU上很快会栈溢出。 使用迭代版或确保基准选择优化 。
  3. 稳定性问题 ：如果你排序的结构体包含多个字段，并且期望在主要关键字相同的情况下，保持次要关键字的原始顺序（即稳定排序），那么就必须选择稳定的算法（插入、冒泡、归并、计数排序）。使用不稳定的快速排序或堆排序会导致不可预期的结果。
  4. 比较函数错误 ：如果使用C标准库的 qsort ，自定义的比较函数 compare 必须返回 int ，并且遵守“a<b返回负，a==b返回0， a>b返回正”的约定。一个常见的错误是直接返回 a - b ，对于32位整数，如果差值超过 INT_MAX 会导致溢出，产生错误结果。安全的写法是： 
    int compare_int(const void *a, const void *b) {
    int ia = *(const int *)a;
    int ib = *(const int *)b;
    // 避免溢出
    return (ia > ib) - (ia < ib);
}

6.2 如何测量和评估排序性能？

在嵌入式系统，不能只看理论复杂度，必须实测。

  1. 使用硬件定时器 ：在排序函数开始前读取一个高精度定时器（如SysTick或通用定时器）的计数器，结束后再次读取，差值即为CPU周期数。这是最准确的测量方法。 
    uint32_t start_ticks, end_ticks;
start_ticks = DWT_CYCCNT; // 假设使用Cortex-M的DWT周期计数器
my_sort_function(data, size);
end_ticks = DWT_CYCCNT;
uint32_t cycles_used = end_ticks - start_ticks;
  2. 测试数据集 ：不要只用随机数据测试。必须包含以下典型用例：
    • 随机数据 ：评估平均性能。
    • 已排序数据 ：评估对有序输入的适应性，检验快速排序是否会退化。
    • 逆序数据 ：同上。
    • 重复数据 ：很多算法在大量重复元素时表现不同。
  3. 关注内存访问 ：使用性能分析工具（如果芯片支持），查看Cache命中率。对于缓存敏感的MCU，一个缓存友好的算法可能比理论更快的算法实际表现更好。

6.3 一个实用的嵌入式排序库设计思路

对于长期项目，建议抽象出一个排序模块：

// sort.h
typedef enum {
    SORT_ALGO_INSERTION,
    SORT_ALGO_QUICK,
    SORT_ALGO_HEAP,
    SORT_ALGO_MERGE
} sort_algo_t;

typedef int (*compare_fn_t)(const void *, const void *);

void sort(void *base, size_t num, size_t size, compare_fn_t compar, sort_algo_t algo);

// 根据数据规模、是否要求稳定、是否要求原地等条件，内部自动选择最佳算法
void sort_auto(void *base, size_t num, size_t size, compare_fn_t compar);

在 sort_auto 函数内部，可以实现一套简单的启发式规则：

  • 如果 num <= 16 ：用插入排序。
  • 如果 num > 16 && num <= 100 ：用希尔排序或快速排序（迭代版）。
  • 如果 num > 100 且要求最坏情况确定：用堆排序。
  • 如果 num > 100 且空间充足：用归并排序（如果需要稳定）。
  • 如果数据是有限范围整数：用计数排序。

这种封装将算法选择的复杂性隐藏起来，为应用层提供简洁统一的接口，同时保证了在大多数情况下的良好性能。

最后，我的个人体会是，在嵌入式开发中，对排序算法的掌握程度，是区分“代码搬运工”和“系统思考者”的一个小标尺。它要求你不仅仅会调用 qsort ，更要理解数据、理解硬件、理解约束，并在其中做出最优雅的权衡。下次当你面对一堆需要整理的数据时，不妨先花几分钟思考一下我们讨论的这些点，这可能会为你省下大量的调试时间，并带来更流畅的产品体验。

# 排序算法
Logo
AI硬件创业社区

智能硬件社区聚焦AI智能硬件技术生态，汇聚嵌入式AI、物联网硬件开发者，打造交流分享平台，同步全国赛事资讯、开展 OPC 核心人才招募，助力技术落地与开发者成长。

更多推荐

技术框架设计全链路方法论：从基础原理到工程实践（三）

设计模式不是背诵的套路，而是从变化类型推导出的必然解法。责任链 Chain of Responsibility。工厂方法 Factory Method。接口定义契约 + 抽象类复用共性。解释器 Interpreter。📐 Step 3：选择设计结构。📋 Step 1：识别变化点。✅ Step 4：验证与评估。接口定义契约 + 运行时路由。装饰器 Decorator。策略 + 模板 + 注册表。

avatar AI硬件创业社区
cover

100.STM32低功耗设计实战：从原理到代码实现

avatar AI硬件创业社区
cover

【proteus仿真】基于STM32单片机矿井环境监测系统设计（仿真图+程序）

avatar AI硬件创业社区