FreeRTOS快速上手

最新推荐文章于 2024-05-29 23:49:12 发布
最新推荐文章于 2024-05-29 23:49:12 发布
阅读量2.4k 收藏 15
点赞数 1
分类专栏： STM32 FreeRTOS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35675731/article/details/105107210
版权

FreeRTOS使用

一. 源码下载和移植文件提取

1.1 源码下载

在网站https://sourceforge.net/projects/freertos/可以找到freertos最新的源码。

1.2 移植文件提取

根据第一步，我们会得到一个freertos源码文件夹(FreeRTOSvxx.x.x)，其下有很多对移植用处不大的文件夹，可以不管，直接打开FreeRTOSvxx.x.x\FreeRTOS\Source即可，我们需要的源码全在这里。

首先是Source下的这几个文件，是整个freertos的核心

在这里插入图片描述

然后是include文件夹下的头文件

在这里插入图片描述

最后是portable文件夹下的RVDS和MemMang文件夹里的文件

在这里插入图片描述
在RDVS文件夹中选择使用的芯片类别，比如我在F103上移植的，那么我就选择ARM_CM3文件夹下的文件。

在这里插入图片描述

打开也就是这些文件

在这里插入图片描述
MemMang中是与内存相关的文件，根据自己需要选择，比如参考别人的移植工程，我就选择heap_4.c
在这里插入图片描述

以上就是需要从源码中提取出来的全部文件，我们可以全部复制出来放到一个方便操作的文件夹，当然就这样也没有任何问题。

二、移植到工程中

2.1 添加源码到工程

这一步跟建立工程时新建分组一样，新建一个freertos的分组再把刚刚的.c文件添加进去，然后把.h文件路径包含到工程就行了

在这里插入图片描述

当然，就这样是肯定不行的，我们还要添加一些移植必要的文件和修改原来的工程文件。

2.2 移植配置文件

对于一块从未接触过的芯片，移植操作系统时往往会找网上的例程，但是请注意，freertos可以用STM32CubeMX直接生成啊，那些必要的配置文件直接复制就行了。

我们使用STM32CubeMX选择自己使用的芯片新建一个激活freertos的工程，然后打开工程文件价下的freertos Source文件夹。

在这里插入图片描述

发现这和我们刚刚下载的源码几乎一样，是的，确实几乎一样，但是它多了一个CMSIS_RTOS文件夹，这里面的cmsis_os.c和cmsis_os.h是使用大量条件语句编程实现的操作系统API调用文件，调用这两个文件里的函数可以在很大程度上脱离繁琐的freertosAPI调用，具体实现查看源码或者百度CMSIS_RTOS就能懂了，不做过多解释，我们只管快速使用。

在这里插入图片描述

然后我们在打开工程文件下的inc文件夹，这有一个至关重要的文件

在这里插入图片描述

全部的移植文件都在这里了，我们只要添加进工程就行了，接下来的事情就是把移植后的错误改正。

2.3 移植错误排除

我直接使用的CubeMX生成的配置文件及源码，现在移植到自己建立的标准库工程，会有很多的错误，需要一一修改。

删除FreeRTOSConfig.h中的main.h
在这里插入图片描述

删除cmsis_os.c中的cmsis_armcc.h
在这里插入图片描述

在cmsis_os.c中添加如下函数

在这里插入图片描述
修改cmsis_os.c中的osMailAlloc函数如下
在这里插入图片描述

修改cmsis_os.c中的osMailCreate

在这里插入图片描述
注释掉stm32f10x_it.c中的两个中断函数

在这里插入图片描述
滴答时钟初始化

在这里插入图片描述

滴答时钟中断

在这里插入图片描述

至此，所有移植任务就完成了，再次编译

在这里插入图片描述

三、操作系统的使用

3.1 任务创建

任务句柄

osThreadId led0TaskHandle;
osThreadId led1TaskHandle;

任务函数

void Led0Task(void const * argument);
void Led1Task(void const * argument);

创建任务

osThreadDef(led0Task, Led0Task, osPriorityNormal, 0, 128);
osThreadDef(led1Task, Led1Task, osPriorityNormal, 0, 128);
led0TaskHandle    = osThreadCreate(osThread(led0Task), NULL);
led1TaskHandle    = osThreadCreate(osThread(led1Task), NULL);

任务代码

void Led0Task(void const * argument)
{
    while(1)
    {
        GPIO_SetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
    }
}

void Led1Task(void const * argument)
{
    while(1)
    {
        GPIO_SetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
        GPIO_ResetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
    }
}

3.2 信号量使用

信号量句柄

osSemaphoreId semaHandle;
osSemaphoreDef(se);

信号量任务

void SemRecvTask(void const * argument);

创建信号量

semaHandle = osSemaphoreCreate(osSemaphore(se), 1);

任务代码

void SemRecvTask(void const * argument)
{
    osStatus sem;
    while(1)
    {
        sem = (osStatus)osSemaphoreWait(semaHandle, osWaitForever);
        if(sem == osOK)
        {
            /*
            **TODO
            */
        }
        osSemaphoreRelease(semaHandle);
        osDelay(500);
    }
}

3.3 信号使用

设置信号

void SingalSendTask(void const * argument)
{
    uint16_t cnt = 0;
    while(1)
    {
        ++cnt;
        if(cnt % 9 == 0)
        {
            printf("task led1 running times: %d\r\n",cnt);
            osSignalSet(led0TaskHandle,0x04);
        }
        GPIO_SetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
        GPIO_ResetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
    }
}

等待信号

void SingalRecvTask(void const * argument)
{
    osEvent event;
    while(1)
    {
        event = osSignalWait(0x04,100);
        if(event.status == osEventSignal)
        {
            if(event.value.signals &0x04)
            {
                printf("lend0 recv val:%d\r\n",event.value.signals);
            }
        }
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
        GPIO_SetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
    }
}

3.4 互斥信号量使用

互斥信号量句柄

osMutexId mutexHandle;

osMutexDef(MUTEX);

互斥信号量任务

void Mutex1RecvTask(void const * argument);
void Mutex2RecvTask(void const * argument);

创建互斥信号量

mutexHandle = osMutexCreate(osMutex(MUTEX));

任务代码

void Mutex1RecvTask(void const * argument)
{
    osStatus err;
    while(1)
    {
        err = osMutexWait(mutexHandle,osWaitForever);
        if(osOK == err)
        {
            printf("led0 recv mutexsem!\r\n");
        }
        err = osMutexRelease(mutexHandle);
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
        GPIO_SetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
    }
}


void Mutex2RecvTask(void const * argument)
{
    osStatus err;
    while(1)
    {
        err = osMutexWait(mutexHandle,osWaitForever);
        if(osOK == err)
        {
            printf("led1 recv mutexsem!\r\n");
        }
        err = osMutexRelease(mutexHandle);
        GPIO_SetBits(GPIOE,GPIO_Pin_5);
        osDelay(200);
        GPIO_ResetBits(GPIOE,GPIO_Pin_5);
        osDelay(200);
    }
}

3.5 消息队列使用

消息队列句柄

osMessageQId msgHandle;
osMessageQDef(MSG, 1, uint8_t*); //发送消息为指针(结构体指针也行)
//osMessageQDef(MSG, 1, uint16_t);//发送整形数值

消息队列任务

void MsgQSendTask(void const * argument);
void MsgQRecvTask(void const * argument);

创建消息队列

msgHandle = osMessageCreate(osMessageQ(MSG),NULL);

任务代码

void MsgQSendTask(void const * argument)
{
    uint16_t cnt = 0;
    osStatus err;
    while(1)
    {
        ++cnt;
        if(cnt % 9 == 0)
        {
            err = osMessagePut(msgHandle, (uint32_t)"say", osWaitForever);
            if(osOK != err)
            {
                printf("send error\r\n");
            }
            else
            {
                printf("send ok\r\n");
            }
            //发送整型
            //osMessagePut(msgHandle, 5, osWaitForever);
        }
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
        GPIO_SetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
    }
}



void MsgQRecvTask(void const * argument)
{
    osEvent event;
    while(1)
    {
        event = osMessageGet(msgHandle, osWaitForever);
        if(event.status == osEventMessage)
        {
            if(event.def.message_id == msgHandle)
            {
                printf("lend1 recv val:%s\r\n",(uint8_t *)event.value.p);
            }
        }
        //只有收到消息后才执行
        GPIO_SetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
        GPIO_ResetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
    }
}

3.6 消息邮箱使用

消息邮箱句柄

osMailQId mailHandle;
osMailQDef(MAIL, 1, uint16_t);

消息邮箱任务

void MailSendTask(void const * argument);
void MailRecvTask(void const * argument);

创建消息邮箱

mailHandle = osMailCreate(osMailQ(MAIL),NULL);

任务代码

void MailSendTask(void const * argument)
{
    uint16_t cnt = 0;
    osStatus err;
    while(1)
    {
        ++cnt;
        if(cnt % 9 == 0)
        {
            err = osMailPut(mailHandle, (uint8_t *)"say hi");
            if(osOK != err)
            {
                printf("send error\r\n");
            }
            else
            {
                printf("send ok\r\n");
            }
        }
        GPIO_ResetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
        GPIO_SetBits(GPIOB,GPIO_Pin_5);
        osDelay(200);
    }
}

void MailRecvTask(void const * argument)
{
    osEvent event;
    while(1)
    {
        event = osMailGet(mailHandle, osWaitForever);
        if(event.status == osEventMail)
        {
            if(event.def.mail_id == mailHandle)
            {
                printf("lend1 recv val:%s\r\n",(uint8_t *)event.value.p);
            }
        }
        //接收到邮箱后才执行
        GPIO_SetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
        GPIO_ResetBits(GPIOE,GPIO_Pin_5);
        osDelay(155);
    }
}

3.7 软件定时器使用

软件定时器句柄

osTimerId timHandle;
osTimerDef(TIM, timcCallbackFunction);

回调函数

static void timcCallbackFunction()
{
//     printf("i am timer\r\n");
         LED1 = !LED1;
}

创建软件定时器

timHandle = osTimerCreate(osTimer(TIM), osTimerPeriodic, NULL);

任务代码

void TimTask(void const * argument)
{
    uint16_t cnt = 0;
         osTimerStart(timHandle, 100);
         while(1)
         {
                 ++cnt;
                 if(cnt == 10)
                 {
                          osTimerStop(timHandle);
                 }
                 if(cnt == 20)
                 {
                          osTimerStart(timHandle, 300);
                 }
                 GPIO_ResetBits(GPIOB,GPIO_Pin_5);
                 osDelay(200);
                 GPIO_SetBits(GPIOB,GPIO_Pin_5);
                 osDelay(200);
         }
}

四、参考代码

4.1 main.c

#include "sys.h"

#include "usart.h"

#include "led.h"

#include "delay.h"

#include "cmsis_os.h"

#include "FreeRTOS.h"



int main(void)

{

         clock_init();

         uart_init(115200);

         LED_Init();

         MX_FREERTOS_Init();

         osKernelStart();

}

4.2 freertos.c

#include "FreeRTOS.h"

#include "task.h"

#include "cmsis_os.h"

#include "stm32f10x.h"

#include "usart.h"

#include "stdio.h"

#include "led.h"



//优先级

osPriority prio;





//程序运行状态

osThreadState taskstate;





//任务句柄

osThreadId defaultTaskHandle;

osThreadId led0TaskHandle;

osThreadId led1TaskHandle;

osThreadId printTaskHandle;



//任务函数

void StartDefaultTask(void const * argument);

void Led0Task(void const * argument);

void Led1Task(void const * argument);

void PrintTask(void const * argument);





//信号量

osSemaphoreId semaHandle;

osSemaphoreDef(se);



//信号量任务

void SemSendTask(void const * argument);

void SemRecvTask(void const * argument);





//信号任务

void SingalSendTask(void const * argument);

void SingalRecvTask(void const * argument);





//消息队列

osMessageQId msgHandle;

osMessageQDef(MSG, 1, uint8_t*); //发送消息为指针(结构体指针也行)

//osMessageQDef(MSG, 1, uint16_t);//发送整形数值



//消息队列函数

void MsgQSendTask(void const * argument);

void MsgQRecvTask(void const * argument);





//消息邮箱

osMailQId mailHandle;

osMailQDef(MAIL, 1, uint16_t);



//消息邮箱函数

void MailSendTask(void const * argument);

void MailRecvTask(void const * argument);





//互斥信号量

osMutexId mutexHandle;

osMutexDef(MUTEX);



//互斥信号量函数

void Mutex1RecvTask(void const * argument);

void Mutex2RecvTask(void const * argument);





//软件定时器

static void timcCallbackFunction();

osTimerId timHandle;

osTimerDef(TIM, timcCallbackFunction);



void TimTask(void const * argument);





void MX_FREERTOS_Init(void) {



    //任务初始化

    osThreadDef(defaultTask, StartDefaultTask, osPriorityNormal, 0, 128);

    osThreadDef(led0Task, Led0Task, osPriorityNormal, 0, 128);

    osThreadDef(led1Task, Led1Task, osPriorityNormal, 0, 128);

    osThreadDef(printTask, PrintTask, osPriorityNormal, 0, 128);



    //创建任务

    defaultTaskHandle = osThreadCreate(osThread(defaultTask), NULL);

    led0TaskHandle    = osThreadCreate(osThread(led0Task), NULL);

    led1TaskHandle    = osThreadCreate(osThread(led1Task), NULL);

    printTaskHandle   = osThreadCreate(osThread(printTask), NULL);



    //创建信号量

    semaHandle = osSemaphoreCreate(osSemaphore(se), 1);

    if(NULL != semaHandle)

    {

        //printf("Sem create success!\r\n");

    }



    //创建消息队列

    msgHandle = osMessageCreate(osMessageQ(MSG),NULL);



    //创建消息邮箱

    mailHandle = osMailCreate(osMailQ(MAIL),NULL);



    //创建互斥信号量

    mutexHandle = osMutexCreate(osMutex(MUTEX));



    timHandle = osTimerCreate(osTimer(TIM), osTimerPeriodic, NULL);

}





void StartDefaultTask(void const * argument)

{

    for(;;)

    {

        osDelay(11);

    }

}





void Led0Task(void const * argument)

{

    while(1)

    {

        GPIO_SetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

        GPIO_ResetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

    }

}





void Led1Task(void const * argument)

{

    while(1)

    {

        GPIO_SetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

        GPIO_ResetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

    }

}







void PrintTask(void const * argument)

{

    while(1)

    {

        osDelay(100);

    }

}





/*软件定时器使用

**实现软件精确延时

*/



static void timcCallbackFunction()

{

//     printf("i am timer\r\n");

         LED1 = !LED1;

}



void TimTask(void const * argument)

{

    uint16_t cnt = 0;

         osTimerStart(timHandle, 100);

         while(1)

         {

                 ++cnt;

                 if(cnt == 10)

                 {

                          osTimerStop(timHandle);

                 }

                 if(cnt == 20)

                 {

                          osTimerStart(timHandle, 300);

                 }

                 GPIO_ResetBits(GPIOB,GPIO_Pin_5);

                 osDelay(200);

                 GPIO_SetBits(GPIOB,GPIO_Pin_5);

                 osDelay(200);

         }

}





/*互斥信号量

**保证一个资源在一个时刻只能由一个任务访问

**和信号量使用方式一样

*/

void Mutex1RecvTask(void const * argument)

{

    osStatus err;

    while(1)

    {

        err = osMutexWait(mutexHandle,osWaitForever);

        //err = osSemaphoreWait(semaHandle, osWaitForever);

        if(osOK == err)

        {

            printf("led0 recv mutexsem!\r\n");

        }

        err = osMutexRelease(mutexHandle);

        //err = osSemaphoreRelease(semaHandle);

        GPIO_ResetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

        GPIO_SetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

    }

}



void Mutex2RecvTask(void const * argument)

{

    osStatus err;

    while(1)

    {

        err = osMutexWait(mutexHandle,osWaitForever);

        //err = osSemaphoreWait(semaHandle, osWaitForever);

        if(osOK == err)

        {

            printf("led1 recv mutexsem!\r\n");

        }

        err = osMutexRelease(mutexHandle);

        //err = osSemaphoreRelease(semaHandle);

        GPIO_SetBits(GPIOE,GPIO_Pin_5);

        osDelay(200);

        GPIO_ResetBits(GPIOE,GPIO_Pin_5);

        osDelay(200);

    }

}



/*消息邮箱

**和消息队列使用十分类似

***/

void MailSendTask(void const * argument)

{

    uint16_t cnt = 0;

    osStatus err;

    while(1)

    {

        ++cnt;

        if(cnt % 9 == 0)

        {

            err = osMailPut(mailHandle, (uint8_t *)"say hi");

            if(osOK != err)

            {

                printf("send error\r\n");

            }

            else

            {

                printf("send ok\r\n");

            }

        }

        GPIO_ResetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

        GPIO_SetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

    }

}



void MailRecvTask(void const * argument)

{

    osEvent event;

    while(1)

    {

        event = osMailGet(mailHandle, osWaitForever);

        if(event.status == osEventMail)

        {

            if(event.def.mail_id == mailHandle)

            {

                printf("lend1 recv val:%s\r\n",(uint8_t *)event.value.p);

            }

        }

        //接收到邮箱后才执行

        GPIO_SetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

        GPIO_ResetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

    }

}





/*消息队列

**主要就是掌握这put和get两个函数

**以及看下这个结构体，如何取出消息来

typedef struct  {

  osStatus                 status;     ///< status code: event or error information

  union  {

    uint32_t                    v;     ///< message as 32-bit value

    void                       *p;     ///< message or mail as void pointer

    int32_t               signals;     ///< signal flags

  } value;                             ///< event value

  union  {

    osMailQId             mail_id;     ///< mail id obtained by \ref osMailCreate

    osMessageQId       message_id;     ///< message id obtained by \ref osMessageCreate

  } def;                               ///< event definition

} osEvent;

***/

void MsgQSendTask(void const * argument)

{

    uint16_t cnt = 0;

    osStatus err;

    while(1)

    {

        ++cnt;

        if(cnt % 9 == 0)

        {

            err = osMessagePut(msgHandle, (uint32_t)"say", osWaitForever);

            if(osOK != err)

            {

                printf("send error\r\n");

            }

            else

            {

                printf("send ok\r\n");

            }

            //发送整型

            //osMessagePut(msgHandle, 5, osWaitForever);

        }

        GPIO_ResetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

        GPIO_SetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

    }

}



void MsgQRecvTask(void const * argument)

{

    osEvent event;

    while(1)

    {

        event = osMessageGet(msgHandle, osWaitForever);

        if(event.status == osEventMessage)

        {

            if(event.def.message_id == msgHandle)

            {

                printf("lend1 recv val:%s\r\n",(uint8_t *)event.value.p);

            }

        }



        //只有收到消息后才执行

        GPIO_SetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

        GPIO_ResetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

    }

}





/*信号发送和接收



**int32_t osSignalSet (osThreadId thread_id, int32_t signal)；

**thread_id：发送到哪个任务

**signal   ：信号值，用二进制表示



**osEvent osSignalWait (int32_t signals, uint32_t millisec)；

**signals：信号值，跟平时写的那种flag一样，不过这个可以接收多个任务发送来的信号按位判断

**millisec：等待延时

*/

void SingalSendTask(void const * argument)

{

    osEvent event;

    while(1)

    {

        event = osSignalWait(0x04,100);

        if(event.status == osEventSignal)

        {

            if(event.value.signals &0x04)

            {

                printf("lend0 recv val:%d\r\n",event.value.signals);

            }

        }



        osSignalSet(led1TaskHandle,0x08);

        GPIO_ResetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

        GPIO_SetBits(GPIOB,GPIO_Pin_5);

        osDelay(200);

    }

}





void SingalRecvTask(void const * argument)

{

    uint16_t cnt = 0;

    osEvent event;



    while(1)

    {

        ++cnt;

        if(cnt % 9 == 0)

        {

            printf("task led1 running times: %d\r\n",cnt);

            osSignalSet(led0TaskHandle,0x04);

        }



        event = osSignalWait(0x08,100);

        if(event.status == osEventSignal)

        {

            if(event.value.signals &0x08)

            {

                printf("led1 recv val:%d\r\n",event.value.signals);

            }

        }

        GPIO_SetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

        GPIO_ResetBits(GPIOE,GPIO_Pin_5);

        osDelay(155);

    }

}









/*信号量的接收和释放



**osSemaphoreId semaHandle;//创建句柄

**osSemaphoreDef(se);  //定义

**semaHandle = osSemaphoreCreate(osSemaphore(se), 1);创建信号量

**osSemaphoreRelease(semaHandle);释放到另一个任务

**osSemaphoreWait(semaHandle, osWaitForever);接收

*/





void SemRecvTask(void const * argument)

{

    osStatus sem;

    while(1)

    {

        sem = (osStatus)osSemaphoreWait(semaHandle, osWaitForever);

        if(sem == osOK)

        {

            /*

            **TODO

            */

            //printf("get it %d\r\n", (uint16_t)semaHandle);

        }

        osSemaphoreRelease(semaHandle);

        osDelay(500);

    }

}
薯条可乐
关注
  • 1
    点赞
  • 踩
  • 15
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
FreeRTOS2022版本
04-12
此外，示例项目也可能得到更新，帮助新手快速上手。 7. **开源社区支持**：作为开源项目，FreeRTOS 社区的活跃度是其持续发展的重要驱动力。2022版本可能响应了社区反馈，修复了已知问题，并采纳了一些有益的贡献。...
FreeRTOS个人用
03-12
这个“FreeRTOS个人用”压缩包可能是为了方便开发者在个人项目中快速上手和使用FreeRTOS而准备的。在本文中，我们将详细探讨FreeRTOS的核心特性、工作原理以及如何在个人项目中应用它。 1. **FreeRTOS概述** - **...
基于FreeRtos的快速入门学习（韦东山）
fg247778718的博客
01-07 1174
学习韦东山freertos快速入门的一些要点
FreeRTOS移植
weixin_59349642的博客
02-27 442
目录什么是FreeRTOS移植初步认识简单的点灯框架 什么是FreeRTOS RTOS 全程为 Real time OS 就是 实时操作系统 强调的是 实时性。 实时操作系统 又分为软件实时和硬实时 ，硬实时 要求在规定时间内必须完成操作 ， 硬实时不允许超时，软实时就没那么严格了。可以把要实现的功能划分为多个任务， 每个任务 负责 实现其中一部分 每个任务都是一个简单的程序 通常是一个死循环。 RTOS的核心是实时内核 移植 1）获取移植文件的方法 链接 https://freertos.org/a
FreeRTOS基础（一）：FreeRTOS入门
最新发布
weixin_47040031的博客
05-29 852
裸机：直接对硬件资源的编程，所有功能函数放在主循环中，同⼀时间只能单⼀任务运行。裸机又称为前后台系统，前台系统指的中断服务函数，后台系统指的大循环，即应用程序。RTOS是指一类系统，如 FreeRTOS，uC/OS，RTX，RT-Thread 等，都是 RTOS 类操作系统。FreeRTOS 是一个免费的嵌入式实时操作系统，其开源、轻量级、可移植的特点使其成为许多嵌入式开发者的首选。在近几年的使用排名上位居前列。
stm32cubemx hal学习记录：FreeRTOS消息队列
ohhjack的博客
11-21 2889
stm32
【FreeRtos教程四】STM32 CubeMx——Mail（邮箱）
Joseph Wen的博客
01-01 2029
邮箱是特殊的队列，具有如下特点：队列长度只有1。写邮箱：新数据覆盖旧数据 ，既然是覆盖，那么无论邮箱中是否有数据，这些函数总能成功写入数据。读邮箱：读数据时，数据不会被移除 这意味着，第一次调用时会因为无数据而阻塞，一旦曾经写入数据，以后读邮箱时总能成功。
【快速上手ESP32（基于ESP-IDF&VSCode）】特别篇——一文速通FreeRTOS
m0_63235356的博客
04-20 1457
这边插一篇介绍FreeRTOS的文章，因为我在写后续快速上手ESP32系列的文章的时候发现FreeRTOS是越不过去的坎，因此这边补充一下。
RTX RTOS操作实例分析之---邮箱（mailbox）
Andy的博客
04-06 522
mailbox
freertos网课学习实例
07-24
FreeRTOS，全称为“Free Real-Time Operating System”，是一款开源、轻量级的...这个网课实例是一个很好的起点，可以帮助学习者快速上手FreeRTOS，并逐渐掌握在嵌入式系统中使用RTOS设计高效、可靠的软件系统的方法。
STM32F1 FreeRTOS
11-23
FreeRTOS_Pro可能是一个包含示例代码、配置文件和库文件的资源包，帮助开发者快速上手STM32F1上的FreeRTOS开发。它可能包含以下内容： 1. **示例项目**：展示了如何在STM32F1上创建和运行FreeRTOS任务。 2. **配置...
FreeRTOS中文实用教程_52418.pdf
05-04
FreeRTOS是一个迷你的实时操作系统内核。作为一个轻量级的操作系统，功能包括：任务管理、时间管理、信号量、消息队列、内存管理、记录功能、软件定时器、协程等，可基本满足较小系统的需要。 由于RTOS需占用一定的系统资源(尤其是RAM资源)，只有μC/OS-II、embOS、salvo、FreeRTOS等少数实时操作系统能在小RAM单片机上运行。相对μC/OS-II、embOS等商业操作系统，FreeRTOS操作系统是完全免费的操作系统，具有源码公开、可移植、可裁减、调度策略灵活的特点，可以方便地移植到各种单片机上运行
FreeRTOS中文手册
01-15
FreeRTOS中文手册，本文是FreeRTOS官方英文手册的翻译，可供学习FreeRTOS时参考
CMSIS-RTOS API参考手册
06-23
CMSIS-RTOS API参考手册 V1.02 ，根据Keil官方网站文档整理，方便使用FreeRTOS、uc/os等底层操作系统的
【FreeRTOS实战汇总】小白博主的RTOS学习实战快速进阶之路（持续更新）
01-06
博主是个小白，打算把这段时间系统学习RTOS的文章统一整理到这里，另外本文会给出一些参考性资料和指导性建议； 本文宗旨 FreeRTOS 是由Richard Barry在2003年由设计的，由于其设计的小巧简单，整个核心代码只有3到4个C文件。在设计之初就异军突起，累计开发者数百万，是目前市场占有率最高的RTOS，现在FreeRTOS已经支持三十多种芯片，基本包含市场上所有的微控制器。 FreeRTOS在2018年被亚马逊收购，继续遵循GPLV2许可协议完全免费。 Richard Barry为了让代码容易阅读、移植和维护，大部分的代码都是以C语言编写，只有一些内核调度函数采用汇编编写。 Fre
freertos on at32
09-02
示例代码通常包含基本任务创建、中断处理、同步机制等典型用法，有助于快速上手。 在调试FreeRTOS应用时，需要关注系统的中断优先级管理。AT32F系列MCU具有中断优先级分层，FreeRTOS则有自己的任务优先级。理解两者...
FreeRTOS一些常识笔记之快速上手
小浩的博客
05-29 1631
一、为啥要用实时多任务操作系统 real-time Operate System 简称有：RTOS，有如下的好处: 用户无需关心时间信息 内核负责计时，并由相关的API完成，从而使得用户的应用程序代码结构更简单。 模块化、可拓展性强 也正是由于第一点的原因，程序性能不易受底层硬件更改的影响。姐，各个任务是独立的模块，每个模块都有明确的目 的，降低了代码的耦合性。 效率高 内核可以让软件完全由事件驱动，因次,轮询未发生的事件是不浪费时间的。相当于用中断来进行任务切换。 中断进程更短 通过把中断的处理推迟到用
1-FreeRTOS入门指南
南山府的博客
11-28 2280
FreeRTOS内核最初由Richard Barry在2003年左右开发，到现在有19年的历史，可以看出无论是维护还是系统升级能持续到现在都是非常优秀得了。不过在2017年Barry这个公司把FreeRTOS项目的管理权交给了Amazon Web Services（AWS）。但是呢，人家还是作为其中的一员，继续工作。
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2147
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
freertos完全开发手册之快速入门pdf
09-22
FreeRTOS完全开发手册之快速入门PDF是一个面向初学者的指南，旨在帮助他们快速上手使用FreeRTOS实时操作系统。 该PDF提供了全面的介绍，包括了FreeRTOS的基本知识和使用方法。首先，它解释了实时操作系统的概念和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值