04-单片机商业项目编程，从零搭建低功耗系统设计

已于 2024-05-14 16:50:00 修改
阅读量709 收藏 13
点赞数 15
分类专栏： 单片机低功耗系统设计 文章标签： 单片机 嵌入式硬件 低功耗 伪时间片 多任务 C语言 编程
于 2024-05-14 16:45:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liubinkaixin/article/details/138859694
版权

一、本文内容

    上一节《03-单片机商业项目编程，从零搭建低功耗系统设计-CSDN博客》我们确定了设计思路，并如何更有效的保持低功耗，这节我们就准备来做软件框架设计。在AI飞速发展的时代，我们也会利AI来辅助我们完成，让自己也能慢慢学会和AI的合作。

二、软件设计思路

    对于软件代码编写，最重要的还是框架搭建，并不是要一开始就把所有代码一五一十的写出来，而是框架搭建好了，再去填充自己需要的内容，比如单片机的底层驱动之类的；我们软件设计第一步先确定方案构思，第二步开始搭建软件框架，第三步移植到指定芯片。

    当前AI发展十分迅速，很多算法类的代码，都可以不需要自己去编写，而我们更多的是发现问题，修正问题，这样既能够让AI给我们提供思路，又能充分发现AI的思路错误，来理顺自己的思路。我们今天利用Chat GPT来帮我们以STM32F030C8T6构建基础软件框架设计，我们不要求他能够直接能运行，但是要保障他的代码逻辑没有漏洞。这也是我们作为程序员和AI协同的提前练习；当然你也可以选择国内其它AI工具来实现。

三、软件编写过程

    我：能帮我基于STM32F030C8T6，利用systick做一个基于事件触发的低功耗伪时间片调度算法吗？

    GPT：当然可以。以下是一个基于STM32F030C8T6的低功耗伪时间片调度算法的示例。这个例子使用了systick定时器来触发事件。

#include "stm32f0xx.h"

// 定义任务结构体
typedef struct {
    void (*taskFunc)(void); // 任务函数指针
    uint32_t delay; // 任务延迟
    uint32_t period; // 任务周期
    uint8_t run; // 运行标志
} sTask;

#define SCH_MAX_TASKS 5 // 最大任务数

sTask SCH_tasks_G[SCH_MAX_TASKS]; // 任务数组

void SysTick_Handler(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if ((SCH_tasks_G[index].taskFunc != 0) && (SCH_tasks_G[index].delay == 0)) {
            SCH_tasks_G[index].run = 1; // 标记任务为可运行
            if (SCH_tasks_G[index].period) {
                SCH_tasks_G[index].delay = SCH_tasks_G[index].period; // 重置任务延迟
            }
        }
        if (SCH_tasks_G[index].delay > 0) {
            SCH_tasks_G[index].delay--; // 任务延迟递减
        }
    }
}

void SCH_Dispatch_Tasks(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if (SCH_tasks_G[index].run == 1) {
            (*SCH_tasks_G[index].taskFunc)(); // 运行任务
            SCH_tasks_G[index].run = 0; // 清除运行标志
        }
    }
}

void SCH_Add_Task(void (*fPtr)(void), const uint32_t DELAY, const uint32_t PERIOD) {
    uint32_t Index = 0;
    while ((SCH_tasks_G[Index].taskFunc != 0) && (Index < SCH_MAX_TASKS)) {
        Index++;
    }
    if (Index < SCH_MAX_TASKS) {
        SCH_tasks_G[Index].taskFunc = fPtr;
        SCH_tasks_G[Index].delay = DELAY;
        SCH_tasks_G[Index].period = PERIOD;
        SCH_tasks_G[Index].run = 0;
    }
}

int main(void) {
    // 初始化systick定时器
    SysTick_Config(SystemCoreClock / 1000);
    // 添加任务
    SCH_Add_Task(Task1, 0, 1000);
    SCH_Add_Task(Task2, 0, 2000);
    // 主循环
    while (1) {
        SCH_Dispatch_Tasks();
        __WFI(); // 进入低功耗模式
    }
}

    这个例子中，我们定义了一个任务结构体，包含了任务函数指针、任务延迟、任务周期和运行标志。在systick定时器中断服务程序中，我们检查每个任务，如果任务延迟为0，我们就标记任务为可运行，并重置任务延迟。在主循环中，我们检查每个任务，如果任务被标记为可运行，我们就运行任务，并清除运行标志。

    这个例子只是一个基本的框架，你可能需要根据你的具体需求进行修改。希望这个例子能对你有所帮助！

    我：低功耗对我非常重要，你写的代码需要每1ms就要进行一次中断判断，实际还是做了很多无效判断，我希望是动态的调整systick的定时任务，计算出下一任务还需要多长时间执行，就设定多长时间的中断，这样保障系统尽可能的在休眠状态，提高执行效率

    GPT：我理解你的需求，你希望系统能够动态地调整systick的定时任务，以便在尽可能多的时间里让系统处于休眠状态，从而提高执行效率。以下是一个修改后的示例，它会动态地调整systick的定时任务：

#include "stm32f0xx.h"

typedef struct {
    void (*taskFunc)(void);
    uint32_t delay;
    uint32_t period;
    uint8_t run;
} sTask;

#define SCH_MAX_TASKS 5

sTask SCH_tasks_G[SCH_MAX_TASKS];

void SysTick_Handler(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if ((SCH_tasks_G[index].taskFunc != 0) && (SCH_tasks_G[index].delay == 0)) {
            SCH_tasks_G[index].run = 1;
            if (SCH_tasks_G[index].period) {
                SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
            }
        }
        if (SCH_tasks_G[index].delay > 0) {
            SCH_tasks_G[index].delay--;
        }
    }
    // 重新计算下一次中断的时间
    uint32_t nextInterrupt = UINT32_MAX;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 设置下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    SysTick->VAL = 0;
}

void SCH_Dispatch_Tasks(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if (SCH_tasks_G[index].run == 1) {
            (*SCH_tasks_G[index].taskFunc)();
            SCH_tasks_G[index].run = 0;
        }
    }
}

void SCH_Add_Task(void (*fPtr)(void), const uint32_t DELAY, const uint32_t PERIOD) {
    uint32_t Index = 0;
    while ((SCH_tasks_G[Index].taskFunc != 0) && (Index < SCH_MAX_TASKS)) {
        Index++;
    }
    if (Index < SCH_MAX_TASKS) {
        SCH_tasks_G[Index].taskFunc = fPtr;
        SCH_tasks_G[Index].delay = DELAY;
        SCH_tasks_G[Index].period = PERIOD;
        SCH_tasks_G[Index].run = 0;
    }
}

int main(void) {
    SysTick_Config(SystemCoreClock / 1000);
    SCH_Add_Task(Task1, 0, 1000);
    SCH_Add_Task(Task2, 0, 2000);
    while (1) {
        SCH_Dispatch_Tasks();
        __WFI();
    }
}

    在这个修改后的示例中，我在SysTick_Handler函数中添加了一段代码，用于计算下一次中断的时间，并设置systick定时器的加载值。这样，systick定时器的中断时间就会根据任务的需求动态地进行调整，从而使系统能够在尽可能多的时间里处于休眠状态，提高执行效率。希望这个修改后的示例能满足你的需求！

    我：SysTick_Handler()函数能够把每句话加上注释吗，有点看不懂

    GPT：当然可以，我会为SysTick_Handler()函数中的每一行代码添加注释，以帮助你理解。以下是带有注释的代码：

void SysTick_Handler(void) {
    uint32_t index;
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟为0
        if ((SCH_tasks_G[index].taskFunc != 0) && (SCH_tasks_G[index].delay == 0)) {
            // 标记任务为可运行
            SCH_tasks_G[index].run = 1;
            // 如果任务周期不为0，则重置任务延迟
            if (SCH_tasks_G[index].period) {
                SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
            }
        }
        // 如果任务延迟大于0，则递减任务延迟
        if (SCH_tasks_G[index].delay > 0) {
            SCH_tasks_G[index].delay--;
        }
    }
    // 初始化下一次中断的时间为最大值
    uint32_t nextInterrupt = UINT32_MAX;
    // 再次遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟小于下一次中断的时间
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 设置systick定时器的加载值为下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    // 清零systick定时器的当前值
    SysTick->VAL = 0;
}

    这段代码的主要目的是在每次systick定时器中断时更新任务的状态，并计算下一次中断的时间。希望这些注释能帮助你理解这段代码！

    我：我发现这段代码由逻辑错误，因为我们的下一次中断是按最短延时来计算，也就是可能是不定值的毫秒数，而代码这里却每次只是减1操作：// 如果任务延迟大于0，则递减任务延迟

if (SCH_tasks_G[index].delay > 0) {
SCH_tasks_G[index].delay--;
}

    GPT：你的观察非常准确，这确实是一个问题。在这个代码中，我们假设每次中断的时间间隔是1ms，所以每次中断我们只减少1ms的延迟。但是，如果我们动态地改变中断的时间间隔，那么我们就需要减少相应的延迟时间，而不是只减少1ms。我们可以通过修改SysTick_Handler函数来解决这个问题。具体来说，我们可以在计算出下一次中断的时间后，将这个时间间隔从所有任务的延迟中减去。以下是修改后的代码：

void SysTick_Handler(void) {
    uint32_t index;
    // 初始化下一次中断的时间为最大值
    uint32_t nextInterrupt = UINT32_MAX;
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟小于下一次中断的时间
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空
        if (SCH_tasks_G[index].taskFunc != 0) {
            // 如果任务延迟大于下一次中断的时间
            if (SCH_tasks_G[index].delay >= nextInterrupt) {
                // 减去下一次中断的时间
                SCH_tasks_G[index].delay -= nextInterrupt;
                // 如果任务延迟为0
                if (SCH_tasks_G[index].delay == 0) {
                    // 标记任务为可运行
                    SCH_tasks_G[index].run = 1;
                    // 如果任务周期不为0，则重置任务延迟
                    if (SCH_tasks_G[index].period) {
                        SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
                    }
                }
            }
        }
    }
    // 设置systick定时器的加载值为下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    // 清零systick定时器的当前值
    SysTick->VAL = 0;
}

    希望这个修改后的代码能满足你的需求！

    我：感觉还是有点问题，nextInterrupt在前面就获得值了，然后再去遍历任务数组，那不等于本次调用SysTick_Handler中断处理函数，就立即对应的任务标记可运行了？应该是中断下一轮，才到吧，实际上nextInterrupt要定义成static变量，然后更新其值要放后面吧

    GPT：你的观察非常准确，我理解你的担忧。确实，我们应该在下一轮中断时才标记任务为可运行。为了解决这个问题，我们可以将nextInterrupt定义为静态变量，并在每次中断时使用它来更新任务的延迟，然后在中断的最后更新nextInterrupt的值。以下是修改后的代码：

void SysTick_Handler(void) {
    static uint32_t nextInterrupt = 1; // 初始化为1，以便在第一次中断时运行
    uint32_t index;
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空
        if (SCH_tasks_G[index].taskFunc != 0) {
            // 如果任务延迟大于等于下一次中断的时间
            if (SCH_tasks_G[index].delay >= nextInterrupt) {
                // 减去下一次中断的时间
                SCH_tasks_G[index].delay -= nextInterrupt;
                // 如果任务延迟为0
                if (SCH_tasks_G[index].delay == 0) {
                    // 标记任务为可运行
                    SCH_tasks_G[index].run = 1;
                    // 如果任务周期不为0，则重置任务延迟
                    if (SCH_tasks_G[index].period) {
                        SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
                    }
                }
            }
        }
    }
    // 初始化下一次中断的时间为最大值
    nextInterrupt = UINT32_MAX;
    // 再次遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟小于下一次中断的时间
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 设置systick定时器的加载值为下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    // 清零systick定时器的当前值
    SysTick->VAL = 0;
}

    这样，我们就可以确保只有在下一轮中断时才会标记任务为可运行。希望这个修改后的代码能满足你的需求！

    我：嗯，太好了，这个中断处理函数目前没问题了，那么对应的SCH_Add_Task函数也要做一些修正，新增了任务后，对应的nextInterrupt参数和SysTick也要更新

    GPT：你的观察非常准确，当我们添加新的任务时，我们确实需要更新nextInterrupt和systick定时器。以下是修改后的SCH_Add_Task函数：

void SCH_Add_Task(void (*fPtr)(void), const uint32_t DELAY, const uint32_t PERIOD) {
    uint32_t Index = 0;
    // 寻找任务数组中的空闲位置
    while ((SCH_tasks_G[Index].taskFunc != 0) && (Index < SCH_MAX_TASKS)) {
        Index++;
    }
    // 如果找到空闲位置
    if (Index < SCH_MAX_TASKS) {
        // 添加新任务
        SCH_tasks_G[Index].taskFunc = fPtr;
        SCH_tasks_G[Index].delay = DELAY;
        SCH_tasks_G[Index].period = PERIOD;
        SCH_tasks_G[Index].run = 0;
        // 如果新任务的延迟小于下一次中断的时间
        if (DELAY < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = DELAY;
            // 设置systick定时器的加载值为下一次中断的时间
            SysTick->LOAD = nextInterrupt;
            // 清零systick定时器的当前值
            SysTick->VAL = 0;
        }
    }
}

    在这个修改后的函数中，当我们添加新的任务时，我们会检查新任务的延迟是否小于下一次中断的时间。如果是，我们就更新下一次中断的时间，并设置systick定时器的加载值为下一次中断的时间。希望这个修改后的函数能满足你的需求！

    我：那再把上面确定的这些，全部写出来，我再梳理下

    GPT：当然，以下是我们讨论并确定的代码：

#include "stm32f0xx.h"

typedef struct {
    void (*taskFunc)(void);
    uint32_t delay;
    uint32_t period;
    uint8_t run;
} sTask;

#define SCH_MAX_TASKS 5

sTask SCH_tasks_G[SCH_MAX_TASKS];
static uint32_t nextInterrupt = 1; // 初始化为1，以便在第一次中断时运行

void SysTick_Handler(void) {
    uint32_t index;
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空
        if (SCH_tasks_G[index].taskFunc != 0) {
            // 如果任务延迟大于等于下一次中断的时间
            if (SCH_tasks_G[index].delay >= nextInterrupt) {
                // 减去下一次中断的时间
                SCH_tasks_G[index].delay -= nextInterrupt;
                // 如果任务延迟为0
                if (SCH_tasks_G[index].delay == 0) {
                    // 标记任务为可运行
                    SCH_tasks_G[index].run = 1;
                    // 如果任务周期不为0，则重置任务延迟
                    if (SCH_tasks_G[index].period) {
                        SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
                    }
                }
            }
        }
    }
    // 初始化下一次中断的时间为最大值
    nextInterrupt = UINT32_MAX;
    // 再次遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟小于下一次中断的时间
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 设置systick定时器的加载值为下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    // 清零systick定时器的当前值
    SysTick->VAL = 0;
}

void SCH_Add_Task(void (*fPtr)(void), const uint32_t DELAY, const uint32_t PERIOD) {
    uint32_t Index = 0;
    // 寻找任务数组中的空闲位置
    while ((SCH_tasks_G[Index].taskFunc != 0) && (Index < SCH_MAX_TASKS)) {
        Index++;
    }
    // 如果找到空闲位置
    if (Index < SCH_MAX_TASKS) {
        // 添加新任务
        SCH_tasks_G[Index].taskFunc = fPtr;
        SCH_tasks_G[Index].delay = DELAY;
        SCH_tasks_G[Index].period = PERIOD;
        SCH_tasks_G[Index].run = 0;
        // 如果新任务的延迟小于下一次中断的时间
        if (DELAY < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = DELAY;
            // 设置systick定时器的加载值为下一次中断的时间
            SysTick->LOAD = nextInterrupt;
            // 清零systick定时器的当前值
            SysTick->VAL = 0;
        }
    }
}

void SCH_Dispatch_Tasks(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if (SCH_tasks_G[index].run == 1) {
            (*SCH_tasks_G[index].taskFunc)();
            SCH_tasks_G[index].run = 0;
        }
    }
}

int main(void) {
    SysTick_Config(SystemCoreClock / 1000);
    SCH_Add_Task(Task1, 0, 1000);
    SCH_Add_Task(Task2, 0, 2000);
    while (1) {
        SCH_Dispatch_Tasks();
        __WFI();
    }
}

    这段代码实现了一个基于STM32F030C8T6的低功耗伪时间片调度算法，使用了systick定时器来触发事件，并且能够动态地调整systick的定时任务，以...(GPT卡壳了，但不重要)

    我：我觉得在SysTick_Handler()函数中if (SCH_tasks_G[index].delay >= nextInterrupt) 的else情况也写一下，这样更健全点儿，当不知名原因导致delay小于nextInterrupt，定时时间肯定也是到了

    GPT：你的建议非常好，确实应该考虑到这种情况。我们可以在if (SCH_tasks_G[index].delay >= nextInterrupt)后面添加一个else语句，处理delay小于nextInterrupt的情况。以下是修改后的代码：

#include "stm32f0xx.h"

typedef struct {
    void (*taskFunc)(void);
    uint32_t delay;
    uint32_t period;
    uint8_t run;
} sTask;

#define SCH_MAX_TASKS 5

sTask SCH_tasks_G[SCH_MAX_TASKS];
static uint32_t nextInterrupt = 1; // 初始化为1，以便在第一次中断时运行

void SysTick_Handler(void) {
    uint32_t index;
    // 遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空
        if (SCH_tasks_G[index].taskFunc != 0) {
            // 如果任务延迟大于等于下一次中断的时间
            if (SCH_tasks_G[index].delay >= nextInterrupt) {
                // 减去下一次中断的时间
                SCH_tasks_G[index].delay -= nextInterrupt;
                // 如果任务延迟为0
                if (SCH_tasks_G[index].delay == 0) {
                    // 标记任务为可运行
                    SCH_tasks_G[index].run = 1;
                    // 如果任务周期不为0，则重置任务延迟
                    if (SCH_tasks_G[index].period) {
                        SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
                    }
                }
            } else {
                // 如果任务延迟小于下一次中断的时间
                // 标记任务为可运行
                SCH_tasks_G[index].run = 1;
                SCH_tasks_G[index].delay = 0;
                // 如果任务周期不为0，则重置任务延迟
                if (SCH_tasks_G[index].period) {
                    SCH_tasks_G[index].delay = SCH_tasks_G[index].period;
                }
            }
        }
    }
    // 初始化下一次中断的时间为最大值
    nextInterrupt = UINT32_MAX;
    // 再次遍历任务数组
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        // 如果任务函数指针不为空且任务延迟小于下一次中断的时间
        if (SCH_tasks_G[index].taskFunc != 0 && SCH_tasks_G[index].delay < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = SCH_tasks_G[index].delay;
        }
    }
    // 设置systick定时器的加载值为下一次中断的时间
    SysTick->LOAD = nextInterrupt;
    // 清零systick定时器的当前值
    SysTick->VAL = 0;
}

void SCH_Add_Task(void (*fPtr)(void), const uint32_t DELAY, const uint32_t PERIOD) {
    uint32_t Index = 0;
    // 寻找任务数组中的空闲位置
    while ((SCH_tasks_G[Index].taskFunc != 0) && (Index < SCH_MAX_TASKS)) {
        Index++;
    }
    // 如果找到空闲位置
    if (Index < SCH_MAX_TASKS) {
        // 添加新任务
        SCH_tasks_G[Index].taskFunc = fPtr;
        SCH_tasks_G[Index].delay = DELAY;
        SCH_tasks_G[Index].period = PERIOD;
        SCH_tasks_G[Index].run = 0;
        // 如果新任务的延迟小于下一次中断的时间
        if (DELAY < nextInterrupt) {
            // 更新下一次中断的时间
            nextInterrupt = DELAY;
            // 设置systick定时器的加载值为下一次中断的时间
            SysTick->LOAD = nextInterrupt;
            // 清零systick定时器的当前值
            SysTick->VAL = 0;
        }
    }
}

void SCH_Dispatch_Tasks(void) {
    uint32_t index;
    for (index = 0; index < SCH_MAX_TASKS; index++) {
        if (SCH_tasks_G[index].run == 1) {
            (*SCH_tasks_G[index].taskFunc)();
            SCH_tasks_G[index].run = 0;
        }
    }
}

void Task1(void)
{
	
}

void Task2(void)
{
	
}

int main(void) {
    SysTick_Config(SystemCoreClock / 1000);
    SCH_Add_Task(Task1, 0, 1000);
    SCH_Add_Task(Task2, 0, 2000);
    while (1) {
        SCH_Dispatch_Tasks();
        __WFI();
    }
}

    在这个修改后的代码中，如果任务延迟小于下一次中断的时间，我们会立即标记任务为可运行，并重置任务延迟。这样，我们就可以确保在任何情况下，只...(GPT又卡壳了，不重要)

四、总结

    是不是和我们平时单片机编程很不一样，实际上AI编程它总结了很多前任的编程经验，以及足够的框架规范，所以它的整体框架还是不错的，但是它并不会很好的完成每一个细节，甚至有一些bug，这反而正是我们自己已经梳理好的，所以我们给它指导出来即可；这样就和AI协同完成了一个基本框架，接下来自己要做的就是移植到指定的芯片上，完成基本的底层驱动开发即可。

liubinkaixin
关注
  • 15
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
低功耗测试
03-09
物联网日益要求功耗越来越低越来越严格背景下采用是德科技公司研发最新技术和整套测试工具才能保证设计质量。
AT89C51单片机系统课程设计数字时钟控制课程设计-12页
01-27
这个课程设计项目不仅锻炼了学生对AT89C51单片机的编程能力，还涵盖了硬件接口设计、中断系统应用、定时器计数器的使用以及人机交互设计等多个方面，是学习嵌入式系统开发的重要实践环节。通过这个设计，学生将能够...
低功耗实验
ff_juju的博客
11-08 140
低功耗实验
STM32复习笔记（十二）RTC实时时钟（低功耗待机唤醒）
热门推荐
sumjess
09-12 2万+
声明：本篇文章只是个人知识盲区、知识弱点、重点部分的归纳总结，望各位大佬不喜勿喷。梳理顺序是按照正点原子的视频和文档的实际顺序梳理，转载请注明出处。 作者：sumjess 适用：这个视频我已经看过3遍了，总会有忘记的，所以来写这本书的随手笔记，记录重点、易忘点。该博客可以当做字典，也可以当做笔记。 目前内容：RTC实时时钟（低功耗待机唤醒）   一、RTC实时时钟特征与原理： ★  R...
低功耗设计
bleauchat的博客
07-27 1万+
前面的帖子提到过，CMOS电路中的功耗分为两部分：静态功耗和动态功耗； 静态功耗是由漏电流引起的功耗；动态功耗分为翻转功耗和短路功耗，翻转功耗也就是0与1翻转所引发的功耗，而短路功耗则是由于PMOS和NMOS都导通时所引起的功耗； 低功耗设计方法 在设计一个系统时必须清楚性能和功耗的关系，也就是说需要明白你的系统是需要在尽可能低功耗的条件下提高性能，还是在尽可能高性能的条件下降低功耗，这对于...
STM32 待机唤醒
zorrorun's blog
04-12 7308
STM32的3种低功耗模式： 睡眠模式：内核停止，外设如NVIC，系统时钟Systick仍运行。 停止模式：所有时钟都已停止；1.8V内核电源工作；PLL,HIS和HSERC振荡器功能禁止；寄存器和SRAM内容保留。 待机模式：1.8V内核电源关闭；只有备份寄存器和待机电路维持供电；寄存器和SRAM内容全部丢失；实现最低功耗。 STM32的3种低功耗唤醒方式：STM32待机模式：在待机模式下，所有的
STC51单片机-中断控制LED-物联网应用系统设计项目开发
06-13
STC51系列单片机是8051微控制器的一种，以其低功耗、高性价比和丰富的内置功能在嵌入式系统设计中广泛应用。C51是为8051系列设计的高级编程语言，使得编程更加方便。 首先，我们需要理解中断的基本概念。中断是...
温度检测系统设计--单片机课程设计报告.docx
06-30
温度检测系统设计是一种常见的实践项目，特别是在计算机科学与电气工程领域。这个系统主要基于51单片机，具体为AT89S51，用于处理温度数据并进行实时监控。在本课程设计中，学生被要求构建一个能够检测温度、显示...
STC51单片机-控制LED闪亮的仿真-物联网应用系统设计项目开发
06-13
STC51系列单片机是广泛应用的8位微控制器，以其低成本、低功耗和易编程性而受到欢迎。在物联网（IoT）领域，这种单片机常用于实现基本的控制功能和数据采集。 首先，我们来了解STC51单片机的基本结构和工作原理。...
单片机应用系统设计实训教学大纲.docx
12-17
【单片机应用系统设计实训教学大纲】 单片机应用系统设计实训教学是电子工程、自动...通过这些实训项目，学生不仅能提升单片机编程技能，还能培养问题解决能力和系统思维，为未来从事相关领域的工程实践打下坚实基础。
树莓派开发相关知识二
最新发布
weixin_45114627的博客
08-14 113
无论是哪种模式，明明按了1次，却输出很多次，这是为什么呢？实际上，按键按下的一瞬间，会有多个脉冲，故会判定多次按下，需要通过代码进行防抖。由程控自由使用，PIN脚依现实考量可作为通用输入（GPI）或通用输出（GPO）或通用输入与输出（GPIO）。树莓派装载的芯片：BCM2835是一个MCU微处理器，它可以理解为CPU+其它模块的组合。编程使用时，需要导入RPI包中的GPIO模块， as 将此导入的结果用GPIO表示。GPIO输入：就是输入一个电压信号，可以理解为开关打开后电流可以注入的端口。
江科大/江协科技 STM32学习笔记P20
sususu_2001的博客
08-07 932
编码器接口的初始化，第一步，RCC开启时钟，开启GPIO和定时器的时钟，第二步，配置GPIO，这里把PA6和PA7配置成输入模式，第三步，配置时基单元，这里预分频器选择不分频，自动重装寄存器给最大65535，第四步，配置输入捕获单元，只有滤波器和极性选择有用，第五步，配置编码器接口模式，最后，调用TIM_Cmd，启动定时器。
【屏驱MCU】实现文件路径的的挂载
欢迎私信、留言交流
08-14 343
【屏驱MCU】实现文件路径的的挂载
STM32&低功耗与备用备份区域
wwwkkkxxx12138的博客
08-14 941
平常的手机手表为什么可以等为什么可以长时间待机？嵌入式开发板做出的东西能不能也低功耗？复位后数据如很能不丢失？来解决解决
定时器介绍
m0_68615655的博客
08-14 157
【代码】定时器介绍。
【屏显MCU】内存使用总结（二）
欢迎私信、留言交流
08-14 97
> 本文主要介绍 屏显 `MCU` 的内存 > 以下是以屏显` MCU` 的文章系列
【屏驱MCU】系列文章合集
欢迎私信、留言交流
08-14 124
【屏驱MCU】系列文章合集，文章跳转界面
51单片机智能晾衣架：低功耗设计与自动化控制
2. 3.1 主控单元设计：选择AT89C52单片机是因为它具有低功耗、高效能的特点，尽管在处理速度上可能不如更高级别的单片机，但对于本文的分时处理需求来说足够。该单片机具有8位CPU和Flash存储，内部资源丰富，支持...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值