STM32 Freertos

最新推荐文章于 2024-05-24 11:12:54 发布
最新推荐文章于 2024-05-24 11:12:54 发布
阅读量441 收藏
点赞数
文章标签： stm32
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jefferyjiangyiwei/article/details/105460160
版权

FreeRTOS——任务间使用队列同步数据

在嵌入式操作系统中队列是任务间数据交换的常用手段
参考代码中存在两个任务，任务A和任务B。任务A扮演生产者的角色，任务A不断地向队列中填充内容，填充的内容为一个int16_t类型的变量，填充完之后该变量累加；任务B扮演消费者的角色，任务B不断的从队列中提取内容，并通过串口打印


/* Standard includes. */
#include <stdio.h>
#include <stdint.h>
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
/* Library includes. */
#include "stm32f10x.h"
#define LED0_ON() GPIO_SetBits(GPIOB,GPIO_Pin_5);
#define LED0_OFF() GPIO_ResetBits(GPIOB,GPIO_Pin_5);
/* 队列句柄 */
xQueueHandle MsgQueue;
static void prvSetupHardware( void );
void TaskA( void *pvParameters );
void TaskB( void *pvParameters );
void LedInit(void);
void UART1Init( void );
int main( void )
{
    /* 初始化硬件平台 */
    prvSetupHardware();
   
    /* 建立队列 */
    MsgQueue = xQueueCreate( 5 , sizeof( int16_t ) );
    /* 建立任务 */
    xTaskCreate( TaskA, ( signed portCHAR * ) "TaskA", configMINIMAL_STACK_SIZE,
                            NULL, tskIDLE_PRIORITY+3, NULL );
    xTaskCreate( TaskB, ( signed portCHAR * ) "TaskB", configMINIMAL_STACK_SIZE,
                            NULL, tskIDLE_PRIORITY+4, NULL );
    /* 启动OS */
    vTaskStartScheduler();
   
    return 0;
}
/*-----------------------------------------------------------*/
void TaskA( void *pvParameters )
{
    int16_t SendNum = 1;
    for( ;; )
    {
        vTaskDelay( 2000/portTICK_RATE_MS );
        /* 向队列中填充内容 */
        xQueueSend( MsgQueue, ( void* )&SendNum, 0 );
        SendNum++;
    }
}
void TaskB( void *pvParameters )
{
    int16_t ReceiveNum = 0;
    for( ;; )
    {
        /* 从队列中获取内容 */
        if( xQueueReceive( MsgQueue, &ReceiveNum, 100/portTICK_RATE_MS ) == pdPASS)
        {
            printf("ReceiveNum:%d\r\n",ReceiveNum);
        }
    }
}
static void prvSetupHardware( void )
{
    LedInit();
    UART1Init();
}
void LedInit( void )
{
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
    /*LED0 @ GPIOB.5*/
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init( GPIOB, &GPIO_InitStructure );
}
void UART1Init( void )
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
   
    /* 第1步：打开GPIO和USART时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
   
    /* 第2步：将USART1 Tx@PA9的GPIO配置为推挽复用模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    /* 第3步：将USART1 Rx@PA10的GPIO配置为浮空输入模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
   
    /* 第4步：配置USART1参数 */
    USART_InitStructure.USART_BaudRate = 9600;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USART1, &USART_InitStructure);
   
    /* 第5步：使能 USART1， 配置完毕 */
    USART_Cmd(USART1, ENABLE);
}
int fputc(int ch, FILE *f)
{
    /* 写一个字节到USART1 */
    USART_SendData(USART1, (uint8_t) ch);
    /* 等待发送结束 */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    {}
    return ch;
}

总结

  1. xQueueHandle MsgQueue; 声明一个队列句柄，队列句柄可以理解成一个队列的标记，不同的队列具有不同的标记
  2. MsgQueue = xQueueCreate( 5 , sizeof( int16_t ) );
    创建队列，即在内容中开辟固定大小的区域。FreeRTOS中需指定队列的深度和每个元素的字节长度，如果队列的深度为1那么便和uCOS的消息邮箱用法相似。
  3. xQueueSend( MsgQueue, ( void* )&SendNum, 0 );
    向队列中填充内容，第二参数需要取出地址并进行类型转换，第三个参数设置等待时间，在队列满的情况下再往队列中填充内容的话便会阻塞任务，直到等待时间溢出；若此处填充的内容为0的话，则立即返回插入队列结果（成功或失败）
  4. xQueueReceive( MsgQueue, &ReceiveNum, 100/portTICK_RATE_MS )
    从队列中取出内容，第二个参数需要取出地址，第三个参数为等待最大时间，若在等待的时间内队列中没有数据则返回阻塞任务。

FreeRTOS学习笔记——二值型信号量

在嵌入式操作系统中二值型信号量是任务间、任务与中断间同步的重要手段。FreeRTOS的二值型信号量简单易用，下面结合一个具体例子说明FreeRTOS中的二值型信号量如何使用。 示例代码具有一个128字节的串口接收缓冲区，在串口中断中把接收到的字符存入缓冲区中，一旦接收到回车换行符(\r\n)，便通过xSemaphoreGiveFromISR把信号量置“满”，打印任务中使用xSemaphoreTake实现于中断接收函数的同步，xSemaphoreTake把任务挂起，一旦查询到信号量为“满”，通过串口打印结束到的内容，并清空缓冲区

/* Standard includes. */
#include <stdio.h>
#include <string.h>
 
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
 
/* Library includes. */
#include "stm32f10x.h"
 
#define LED0_ON()   GPIO_SetBits(GPIOB,GPIO_Pin_5);
#define LED0_OFF()  GPIO_ResetBits(GPIOB,GPIO_Pin_5);
 
static void Setup(void);
static void PrintTask(void *pvParameters);
 
void LedInit(void);
void UART1Init(void);
 
uint8_t RxBuffer[128];
__IO uint8_t RxCounter = 0;
 
SemaphoreHandle_t xSemaphore;
 
int main(void)
{
    /* 初始化硬件平台 */
    Setup();
    
    /* 创建信号量 */
    xSemaphore = xSemaphoreCreateBinary();
    /* 建立Print任务 */
    xTaskCreate(PrintTask, "Print Task", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+4, NULL);
    /* 启动OS */
    vTaskStartScheduler();
    
    return 0;
}
 
void PrintTask(void *pvParameters)
{
    for(;;)
    {
        if( xSemaphoreTake( xSemaphore, portMAX_DELAY ) == pdTRUE )
        {
            printf("receive:%s", RxBuffer);
            memset(RxBuffer, 0x00, 128);
            RxCounter = 0;
        }
    }
}
 
static void Setup( void )
{
    LedInit();
    UART1Init();
}
 
void LedInit( void )
{
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
    /*LED0 @ GPIOB.5*/
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init( GPIOB, &GPIO_InitStructure );    
}
 
void UART1Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    
    /* 第1步：打开GPIO和USART时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
    
    /* 第2步：将USART1 Tx@PA9的GPIO配置为推挽复用模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    /* 第3步：将USART1 Rx@PA10的GPIO配置为浮空输入模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    /* 第4步：配置USART1参数
    波特率   = 9600
    数据长度 = 8
    停止位   = 1
    校验位   = No
    禁止硬件流控(即禁止RTS和CTS)
    使能接收和发送
    */
    USART_InitStructure.USART_BaudRate = 9600;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USART1, &USART_InitStructure);
    
    /* 第5步：使能 USART1， 配置完毕 */
    USART_Cmd(USART1, ENABLE);
    
    /* 清除发送完成标志 */
    USART_ClearFlag(USART1, USART_FLAG_TC);
    
    /* 使能USART1发送中断和接收中断，并设置优先级 */
    NVIC_InitTypeDef NVIC_InitStructure;
    /* 设定USART1 中断优先级 */
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_KERNEL_INTERRUPT_PRIORITY; 
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    /* 使能接收中断 */
    USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); 
}
 
int fputc(int ch, FILE *f)
{
    /* 写一个字节到USART1 */
    USART_SendData(USART1, (uint8_t) ch);
    /* 等待发送结束 */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    {}
    return ch;
}
 
void USART1_IRQHandler(void)
{
    static BaseType_t xHigherPriorityTaskWoken;
    
    if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET)
    {
        RxBuffer[RxCounter++] = USART_ReceiveData(USART1);
        if (RxCounter > 2 && RxBuffer[RxCounter-2] == '\r' && RxBuffer[RxCounter-1] == '\n') {
            // 在中断中发送信号量
            xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
        }
    }
    
    portYIELD_FROM_ISR( xHigherPriorityTaskWoken );
}

总结：

  1. xSemaphoreHandle xSemaphore;
    信号量句柄，二值型信号量、数值型信号量和互斥型信号量均使用xSemaphoreHandle 类型声明

  2. xSemaphore = xSemaphoreCreateBinary();
    创建信号量

  3. xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );
    在中断中发送信号量，以FromISR结尾的函数具有保护功能，

  4. 如果在任务中发送信号量可使用xSemaphoreGive。

  5. xSemaphoreTake( xSemaphore, portMAX_DELAY );
    等待信号量，等待时间为最大等待时间，如果信号量为“空”任务会处于挂起状态。

  6. 使用xSemaphoreCreateBinary()创建的信号量初始值为"空"。
    中断中发送信号量尽量使用XXXXFromISR。

  7. 某中断的优先级数值应大于configMAX_SYSCALL_INTERRUPT_PRIORITY。

FreeRTOS——互斥型信号量

在嵌入式操作系统中互斥型信号量是任务间资源保护的重要手段。互斥型信号量的使用方法如图1所示。在多数情况下，互斥型信号量和二值型信号非常相似，但是从功能上二值型信号量用于同步，而互斥型信号量用于资源保护。互斥型信号量和二值型信号量还有一个最大的区别，互斥型信号量可以有效解决优先级反转现象。
本例具有两个任务，两个任务都试图通过串口打印内容，此时串口就好比一个“资源”，某个任务使用串口资源时必须保护该资源，使用完串口之后在释放资源。保护和释放动作便对应互斥型信号量的两个基本操作，

/* Standard includes. */
#include <stdio.h>
#include <string.h>
 
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
 
/* Library includes. */
#include "stm32f10x.h"
 
#define LED0_ON()   GPIO_SetBits(GPIOB,GPIO_Pin_5);
#define LED0_OFF()  GPIO_ResetBits(GPIOB,GPIO_Pin_5);
 
static void Setup(void);
void TaskA( void *pvParameters );
void TaskB( void *pvParameters );
 
void LedInit(void);
void UART1Init(void);
 
/* 互斥信号量句柄 */
SemaphoreHandle_t xSemaphore = NULL;
 
int main(void)
{
    /* 初始化硬件平台 */
    Setup();
    /* 创建互斥信号量 */
    xSemaphore = xSemaphoreCreateMutex();
    /* 建立任务 */
    xTaskCreate( TaskA, "TaskA", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+3, NULL );
    xTaskCreate( TaskB, "TaskB", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY+4, NULL );
    /* 启动OS */
    vTaskStartScheduler();
    
    return 0;
}
 
void TaskA( void *pvParameters )
{
    for( ;; )
    {
        xSemaphoreTake( xSemaphore, portMAX_DELAY );
        {
            printf("Task A\r\n");
        }
        xSemaphoreGive( xSemaphore );
        vTaskDelay( 2000/portTICK_RATE_MS );
    }
}
 
void TaskB( void *pvParameters )
{
    for( ;; )
    {
        xSemaphoreTake( xSemaphore, portMAX_DELAY );
        {
            printf("Task B\r\n");
        }
        xSemaphoreGive( xSemaphore );
        vTaskDelay( 1000/portTICK_RATE_MS );
    }
}
 
static void Setup( void )
{
    LedInit();
    UART1Init();
}
 
void LedInit( void )
{
    GPIO_InitTypeDef GPIO_InitStructure;
    RCC_APB2PeriphClockCmd( RCC_APB2Periph_GPIOB, ENABLE );
    /*LED0 @ GPIOB.5*/
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_5;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_Out_PP;
    GPIO_Init( GPIOB, &GPIO_InitStructure );    
}
 
void UART1Init(void)
{
    GPIO_InitTypeDef GPIO_InitStructure;
    USART_InitTypeDef USART_InitStructure;
    
    /* 第1步：打开GPIO和USART时钟 */
    RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA | RCC_APB2Periph_USART1, ENABLE);
    
    /* 第2步：将USART1 Tx@PA9的GPIO配置为推挽复用模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    /* 第3步：将USART1 Rx@PA10的GPIO配置为浮空输入模式 */
    GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
    GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
    GPIO_Init(GPIOA, &GPIO_InitStructure);
    
    /* 第4步：配置USART1参数
    波特率   = 9600
    数据长度 = 8
    停止位   = 1
    校验位   = No
    禁止硬件流控(即禁止RTS和CTS)
    使能接收和发送
    */
    USART_InitStructure.USART_BaudRate = 9600;
    USART_InitStructure.USART_WordLength = USART_WordLength_8b;
    USART_InitStructure.USART_StopBits = USART_StopBits_1;
    USART_InitStructure.USART_Parity = USART_Parity_No;
    USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;
    USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;
    USART_Init(USART1, &USART_InitStructure);
    
    /* 第5步：使能 USART1， 配置完毕 */
    USART_Cmd(USART1, ENABLE);
    
    /* 清除发送完成标志 */
    USART_ClearFlag(USART1, USART_FLAG_TC);
    
    /* 使能USART1发送中断和接收中断，并设置优先级 */
    NVIC_InitTypeDef NVIC_InitStructure;
    // NVIC_PriorityGroupConfig(NVIC_PriorityGroup_1);
    /* 设定USART1 中断优先级 */
    NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;
    NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = configLIBRARY_KERNEL_INTERRUPT_PRIORITY; 
    NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
    NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
    NVIC_Init(&NVIC_InitStructure);
    /* 使能接收中断 */
    // USART_ITConfig(USART1, USART_IT_RXNE, ENABLE); 
}
 
int fputc(int ch, FILE *f)
{
    /* 写一个字节到USART1 */
    USART_SendData(USART1, (uint8_t) ch);
    /* 等待发送结束 */
    while (USART_GetFlagStatus(USART1, USART_FLAG_TXE) == RESET)
    {}
    return ch;
}

总结

SemaphoreHandle_t xSemaphore = NULL;
申明互斥型信号量，在FreeRTOS中二值型信号量和互斥型信号量类型完全相同。
xSemaphore = xSemaphoreCreateMutex();
创建互斥型信号量。
xSemaphoreTake( xSemaphore, portMAX_DELAY );
获得资源的使用权，此处的等待时间为portMAX_DELAY（挂起最大时间），如果任务无法获得资源的使用权，任务会处于挂起状态。
xSemaphoreGive( xSemaphore );
释放资源的使用权。

jefferyjiangyiwei
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
基于FreeRTOS在STM32下完成一个多任务程序
qq_45652400的博客
12-04 235
FreeRTOS入门一、二、 一、 二、
stm32 freeRTOS 任务管理实验 （HAL版）
08-15
STM32 FreeRTOS任务管理实验（HAL版）是嵌入式系统开发中一个重要的实践环节，它涉及到微控制器（MCU）STM32、实时操作系统FreeRTOS以及STM32的HAL（Hardware Abstraction Layer，硬件抽象层）库的使用。FreeRTOS是...
STM32初学者入门FreeRTOS操作系统，多任务实时系统
祎平的博客
04-11 2318
FreeRTOS（Free Real-Time Operating System）是一个开源的嵌入式实时操作系统，它专门设计用于在资源有限的嵌入式系统中运行。FreeRTOS提供了一些用于任务管理、调度、同步和通信的功能，使开发者能够轻松地创建可靠的嵌入式系统。以下是FreeRTOS的一些特点和功能：轻量级：FreeRTOS的内核非常小巧，通常只占用很少的ROM和RAM资源，适合在资源有限的嵌入式系统中使用。
FreeRTOS-移植STM32(HAL库)
weixin_48056272的博客
08-10 394
裸机开发的时钟源默认是Systick，使用FreeRTOS后，FreeRTOS会占用Systick(用来生成1ms的时间片，用于时间片调度)，所以需要另外的时钟源。1.Timebase Source 为什么不使用Systick作为时钟源？V2版本更高级，功能更多，但V1版本大多情况下完全够用。此处不使用Systick作为Timebase的时钟源。2.FreeRTOS 版本为什么使用V1？3.FreeRTOS 各项配置选项卡的解释。二.FreeRTOS一些常见的问题。4.选择FreeRTOS。
【FreeRTOS移植到STM32F103C8T6超详细教程--＞＞＞基于标准库】
最新发布
一杯咖啡，一行代码
05-24 1255
基于STM32F103C8T6标准库 FreeRTOS移植工程模板创建
STM32CubeMX——FREERTOS学习：消息队列Queue
m0_49968063的博客
03-28 2179
队列，也叫消息队列，就是把消息一条一条的排个队。 比如创建了一个消息队列，这个消息队列可以存10条消息。任务A可以往里存消息，任务B也可以往里存。这个存的消息是要讲先来后到的，存满了10条消息就不能存了。假设任务C从里面去消息，也是一条一条的取，按照先后顺序取，先存的先取，后存的后取。信息取一个，队列里面就少一个，取10个之后，消息队列就空了。 往队列里面存消息，如果队列已经满了，可以一直等着，直到队列里面有空位置，也可以等一会，没空位离开。 从队列里面取消息，如果队列已经空了，可以一直等着，直到队列
FreeRTOS移植到STM32F103步骤与注意事项
热门推荐
zhangmh2011的博客
05-29 2万+
原文地址：http://www.openedv.com/thread-77593-1-1.html 前言： 由于之前听过太多人抱怨移植FreeRTOS到STM32有各种各样的问题，小灯经过一年多对FreeRTOS的研究并在公司产品中应用，多少有些心得，接下来就由小灯以最新版的FreeRTOS为例一步一步移植到STM32F103上，并提醒大家某些需要注意的事项。本文档为非正式技术文档，故排版会有
STM32F767 FreeRTOS开发手册V1.1_stm32freertos_
09-28
STM32F767 FreeRTOS开发手册是针对基于ARM Cortex-M7内核的STM32F767微控制器进行实时操作系统FreeRTOS的详细学习资料。FreeRTOS是一款广泛使用的开源实时操作系统，适用于嵌入式系统，特别是对于需要高效、可靠和...
STM32 FreeRTOS Freemodbus RTU Master
06-08
STM32f103 freeRTOS FreeModbus是一款开源的Modbus协议栈，但是只有从机开源，主机源码是需要**收费**的。同时网上也没有发现比较好的开源的Modbus主机协议栈，所以才开发这款支持主机模式的FreeModbus协议栈。本版...
STM32FreeRTOS教程
01-02
STM32FreeRTOS教程主要关注的是如何在STM32微控制器上使用FreeRTOS这一轻量级实时操作系统。STM32是意法半导体公司推出的基于ARM Cortex-M系列内核的微控制器，广泛应用于各种嵌入式系统。FreeRTOS则是一款开源、...
STM32 freeRTOS
03-22
STM32 中 移植 FreeRTOS，STM32 中 移植 FreeRTOS，STM32 中 移植 FreeRTOS，STM32 中 移植 FreeRTOS，STM32 中 移植 FreeRTOS，STM32 中 移植 FreeRTOS
stm32f103+2路USART+SPI+CAN+FreeRTOS操作系统
08-23
stm32f103工程，基于FreeRTOS操作系统，包括消息队等多任务运行。其中2路USART串口通讯。一路SPI BUS，其中应用程序未写，可自行加上。一路CAN通讯。
基于STM32的FreeRTOS串口队列通信
04-27
最简单的任务和中断之间的数据传输：队列 将程序修改为通过队列传送数据 串口中断服务程序中，将读取到的数据发送到队列中 在OnCommunicationTask()中，将接收到的数据通过串口发送出来
基于FreeRTOS和HAL库STM32F1的RTC例程
12-23
基于FreeRTOS操作系统和HAL库函数版本的STM32F103RCT6的LED,USART和RTC例程。USART1采用二值信号量同步中断与任务，RTC每10秒（可以自行设定，已将函数引出到main函数）中断一次，直接在中断函数中打印信息到串口。本代码是很好的一个例程，可以用来作为基础工程使用。
FreeOS在STM32上的使用
04-21
小型多任务嵌入式系统简介 不同的多任务系统有不同的侧重点。以工作站和桌面电脑为例：  早期的处理器非常昂贵，所以那时的多任务用于实现在单处理器上支持多用户。这 类系统中的调度算法侧重于让每个用户”公平共享”处理器时间。  随着处理器功能越来越强大，价格却更偏宜，所以每个用户都可以独占一个或多个 处理器。这类系统的调度算法则设计为让用户可以同时运行多个应用程序，而计算 机也不会显得反应迟钝。例如某个用户可能同时运行了一个字处理程序，一个电子 表格，一个邮件客户端和一个 WEB 浏览器，并且期望每个应用程序任何时候都能 对输入有足够快的响应时间。
STM32移植freeRTOS
qq_52885411的博客
03-17 1311
在去freeRTOS源码文件中的Demo中去找对应的FreeRTOSConfig.h文件（F407ZGT6的FreeRTOSConfig.h在CORTEX_M4F_STM32F407ZG-SK文件夹下），并将FreeRTOSConfig.h文件放到Source下的include文件夹下。2、freeRTOSConfig.h文件中一定要有那三个中断宏的定义，记得屏蔽stm32fxxx_it.c中的那三个中断服务函数否则会报重复定义的错。然后将freeRTOS中的Source文件复制到407的过程文件下。
【STM32】使用CubeMX快速创建FreeRTOS的基础工程，基于正点原子
youuuuvvu的博客
08-29 1921
使用STM32F103C8T6开发板，用STM32CubeMX配置FreeRTOS，可以适配正点原子FreeRTOS所有实验的基础工程。
FreeRTOS移植(STM32F103C8T6)
m0_65737814的博客
04-24 776
STM32F103C8T6 FreeRTOS移植记录
【Freertos基础入门】队列(queue)的使用
m0_62599305的博客
08-19 1700
FreeRTOS是一个广泛使用的开源实时操作系统（RTOS），它提供了丰富的功能和特性，使嵌入式系统的开发更加简单和高效。队列是FreeRTOS中常用的一种通信机制，它用于在任务之间传递数据。队列是FreeRTOS中一种有用的通信机制，可用于在任务之间传递数据。通过使用队列，我们可以实现任务之间的数据共享和同步。在使用队列时，需要注意队列的深度和每个数据项的大小，并选择适当的阻塞等待时间以避免资源争用和任务饥饿等问题。
STM32FreeRTos
07-28
STM32FreeRTOS是指在STM32微控制器上使用FreeRTOS实时操作系统的开发方式。STM32微控制器广泛应用于嵌入式领域，并且FreeRTOS具有高度可移植性，可以很容易地与不同型号的STM32微控制器集成。官方提供了针对STM32...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值