【一起来玩RTOS系列】之RT-Thread 事件用于线程同步
事件事件主要用于线程间的同步，与信号量不同，它的特点是可以实现一对多，多对多的同步。即一个线程可等待多个事件的触发：可以是其中任意一个事件唤醒线程进行事件处理的操作；也可以是几个事件都到达后才唤醒线程进行后续的处理；同样，事件也可以是多个线程同步多个事件，这种多个事件的集合可以用一个32位无符号整型变量来表示，变量的每一位代表一个事件，线程通过“逻辑与”或“逻辑或”与一个或多个事件建立关联，形成一个事件集。事件的“逻辑或”也称为是独立型同步，指的是线程与任何事件之一发生同步；事件“逻辑与”也称为是关联型同步，指的是线程与若干事件都发生同步。
RT-Thread定义的事件有以下特点：
事件只与线程相关，事件间相互独立：每个线程拥有32个事件标志，采用一个32 bit无符号整型数进行记录，每一个bit代表一个事件。若干个事件构成一个事件集；
事件仅用于同步，不提供数据传输功能；
事件无排队性，即多次向线程发送同一事件(如果线程还未来得及读走)，其效果等同于只发送一次。
在RT-Thread实现中，每个线程都拥有一个事件信息标记，它有三个属性，分别是RT_EVENT_FLAG_AND(逻辑与)，RT_EVENT_FLAG_OR(逻辑或）以及RT_EVENT_FLAG_CLEAR (清除标记）。当线程等待事件同步时，可以通过32个事件标志和这个事件信息标记来判断当前接收的事件是否满足同步条件。
如图所示，线程#1的事件标志中第2位和第29位被置位，如果事件信息标记位设为逻辑与，则表示线程#1只有在事件1和事件29都发生以后才会被触发唤醒，如果事件信息标记位设为逻辑或，则事件1或事件29中的任意一个发生都会触发唤醒线程#1。如果信息标记同时设置了清除标记位，则当线程#1唤醒后将主动把事件1和事件29清为零，否则事件标志将依然存在（即置1）。
事件控制块
struct rt_event
{
struct rt_ipc_object parent; /* 继承自ipc_object类 */
rt_uint32_t set; /* 事件集合 */
};
/* rt_event_t是指向事件结构体的指针 */
typedef struct rt_event* rt_event_t;
rt_event对象从rt_ipc_object 中派生，由IPC容器管理。
事件相关接口
创建事件
当创建一个事件时，内核首先创建一个事件控制块，然后对该事件控制块进行基本的初始化，创建事件使用下面的函数接口：
rt_event_t rt_event_create (const char* name, rt_uint8_t flag);
调用该函数接口时，系统会从动态内存堆中分配事件对象，然后进行对象的初始化，IPC对象初始化，并把set设置成0。
函数参数
参数描述
name事件的名称；
flag事件的标志，可以使用如下的数值：
#define RT_IPC_FLAG_FIFO 0x00 /* IPC参数采用FIFO方式*/
#define RT_IPC_FLAG_PRIO 0x01 /* IPC参数采用优先级方式*/
函数返回
创建成功返回事件对象的句柄；创建失败返回RT_NULL。
删除事件
系统不再使用事件对象时，通过删除事件对象控制块来释放系统资源。删除事件可以使用下面的函数接口：
rt_err_t rt_event_delete (rt_event_t event);
在调用rt_event_delete函数删除一个事件对象时，应该确保该事件不再被使用。在删除前会唤醒所有挂起在该事件上的线程（线程的返回值是-RT_ERROR），然后释放事件对象占用的内存块。
函数参数
参数描述
event事件对象的句柄。
函数返回
RT_EOK
初始化事件
静态事件对象的内存是在系统编译时由编译器分配的，一般放于数据段或ZI段中。在使用静态事件对象前，需要先行对它进行初始化操作。初始化事件使用下面的函数接口：
rt_err_t rt_event_init(rt_event_t event, const char* name, rt_uint8_t flag);
调用该接口时，需指定静态事件对象的句柄（即指向事件控制块的指针），然后系统会初始化事件对象，并加入到系统对象容器中进行管理。
函数参数
参数描述
event事件对象的句柄。
name事件名称；
flag事件的标志，可以使用如下的数值：
#define RT_IPC_FLAG_FIFO 0x00 /* IPC参数采用FIFO方式*/
#define RT_IPC_FLAG_PRIO 0x01 /* IPC参数采用优先级方式*/
函数返回
RT_EOK
脱离事件
脱离事件是将事件对象从内核对象管理器中删除。脱离事件使用下面的函数接口：
rt_err_t rt_event_detach(rt_event_t event);
用户调用这个函数时，系统首先唤醒所有挂在该事件等待队列上的线程（线程的返回值是- RT_ERROR ），然后将该事件从内核对象管理器中删除。
函数参数
参数描述
event事件对象的句柄。
函数返回
RT_EOK
接收事件
内核使用32位的无符号整型数来标识事件，它的每一位代表一个事件，因此一个事件对象可同时等待接收32个事件，内核可以通过指定选择参数“逻辑与”或“逻辑或”来选择如何激活线程，使用“逻辑与”参数表示只有当所有等待的事件都发生时才激活线程，而使用“逻辑或”参数则表示只要有一个等待的事件发生就激活线程。接收事件使用下面的函数接口：
rt_err_t rt_event_recv(rt_event_t event, rt_uint32_t set, rt_uint8_t option,
rt_int32_t timeout, rt_uint32_t* recved);
当用户调用这个接口时，系统首先根据set参数和接收选项来判断它要接收的事件是否发生，如果已经发生，则根据参数option上是否设置有RT_EVENT_FLAG_CLEAR来决定是否重置事件的相应标志位，然后返回（其中recved参数返回收到的事件）； 如果没有发生，则把等待的set和option参数填入线程本身的结构中，然后把线程挂起在此事件对象上，直到其等待的事件满足条件或等待时间超过指定的超时时间。如果超时时间设置为零，则表示当线程要接受的事件没有满足其要求时就不等待，而直接返回-RT_TIMEOUT。
函数参数
参数描述
event事件对象的句柄。
set接收线程感兴趣的事件；
option接收选项；
timeout指定超时时间；
recved指向收到的事件；
函数返回
正确接收返回RT_EOK，超时返回-RT_TIMEOUT，其他返回-RT_ERROR。
发送事件
通过发送事件服务，可以发送一个或多个事件。发送事件可以使用下面的函数接口：
rt_err_t rt_event_send(rt_event_t event, rt_uint32_t set);
使用该函数接口时，通过参数set指定的事件标志来设定event对象的事件标志值，然后遍历等待在event事件对象上的等待线程链表，判断是否有线程的事件激活要求与当前event对象事件标志值匹配，如果有，则唤醒该线程。
函数参数
参数描述
event事件对象的句柄。
set发送的事件集；
函数返回
RT_EOK
使用场合
事件可使用于多种场合，它能够在一定程度上替代信号量，用于线程间同步。一个线程或中断服务例程发送一个事件给事件对象，而后等待的线程被唤醒并对相应的事件进行处理。但是它与信号量不同的是，事件的发送操作在事件未清除前，是不可累计的，而信号量的释放动作是累计的。 事件另外一个特性是，接收线程可等待多种事件，即多个事件对应一个线程或多个线程。同时按照线程等待的参数，可选择是“逻辑或”触发还是“逻辑与”触发。这个特性也是信号量等所不具备的，信号量只能识别单一的释放动作，而不能同时等待多种类型的释放。 如图所示：
各个事件类型可分别发送或一起发送给事件对象，而事件对象可以等待多个线程，它们仅对它们感兴趣的事件进行关注。当有它们感兴趣的事件发生时，线程就将被唤醒并进行后续的处理动作。
接下来在机智云Gokit智能硬件开发板上演示如何创建并使用事件进行线程的同步。程序创建3个相同优先级的线程1、2、3，并初始化一个静态事件对象， 线程2定时发送事件 (事件3)，线程3定时发送事件 (事件5)，线程1等待在事件对象上以接收事件，演示了采用逻辑与和逻辑或的方式。
/**
************************
* File Name : main.c
* Description : Main program body
************************
** This notice applies to any and all portions of this file
* that are not between comment pairs USER CODE BEGIN and
* USER CODE END. Other portions of this file, whether
* inserted by the user or by software development tools
* are owned by their respective copyright owners.
*
* COPYRIGHT(c) 2017 STMicroelectronics
*
* Redistribution and use in source and binary forms, with or without modification,
* are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
* 3. Neither the name of STMicroelectronics nor the names of its contributors
* may be used to endorse or promote products derived from this software
* without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
************************
*/
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "stm32f1xx_hal.h"
#include "usart.h"
#include "gpio.h"
/* USER CODE BEGIN Includes */
#include "rtthread.h"
#include "string.h"
/* USER CODE END Includes */
/* Private variables ---------------------------------------------------------*/
/* USER CODE BEGIN PV */
/* Private variables ---------------------------------------------------------*/
/* USER CODE END PV */
/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/
/* USER CODE END PFP */
/* USER CODE BEGIN 0 */
//重映射串口1到rt_kprintf
void rt_hw_console_output(const char *str)
{
/* empty console output */
char aa='\r';
rt_enter_critical();
while(*str!='\0')
{
if(*str=='\n')
{
HAL_UART_Transmit(&huart1, (uint8_t *)&aa, 1, 10);
}
HAL_UART_Transmit(&huart1, (uint8_t *)(str++), 1, 10);
}
rt_exit_critical();
}
void rt_hw_us_delay(int us)
{
rt_uint32_t delta;
/* 获得延时经过的tick数 */
us = us * (SysTick->LOAD/(1000000/RT_TICK_PER_SECOND));
/* 获得当前时间 */
delta = SysTick->VAL;
/* 循环获得当前时间，直到达到指定的时间后退出循环 */
while (delta - SysTick->VAL< us);
}
void rt_hw_ms_delay(int ms)
{
int i=0,j=0;
for(j=0;j<ms;j++)
{
for (i=0;i<2;i++)
rt_hw_us_delay(500);
}
}
uint32_t rt_hw_delay_Init(void)
{
#if !defined(STM32F0xx)
uint32_t c;
/* Enable TRC */
CoreDebug->DEMCR &= ~0x01000000;
CoreDebug->DEMCR |=0x01000000;
/* Enable counter */
DWT->CTRL &= ~0x00000001;
DWT->CTRL |=0x00000001;
/* Reset counter */
DWT->CYCCNT = 0;
/* Check if DWT has started */
c = DWT->CYCCNT;
/* 2 dummys */
__ASM volatile ("NOP");
__ASM volatile ("NOP");
/* Return difference, if result is zero, DWT has not started */
return (DWT->CYCCNT - c);
#else
/* Return OK */
return 1;
#endif
}
void rt_hw_delay_us(__IO uint32_t micros)
{
#if !defined(STM32F0xx)
uint32_t start = DWT->CYCCNT;
/* Go to number of cycles for system */
micros *= (HAL_RCC_GetHCLKFreq() / 1000000);
/* Delay till end */
while ((DWT->CYCCNT - start) < micros);
#else
/* Go to clock cycles */
micros *= (SystemCoreClock / 1000000) / 5;
/* Wait till done */
while (micros--);
#endif
}
void rt_hw_delay_ms(__IO uint32_t mills)
{
rt_hw_delay_us(1000*mills);
}
/*
* 程序清单：事件
*
* 这个程序会创建3个动态线程及初始化一个静态事件对象
* 一个线程1等待在事件对象上以接收事件；
* 一个线程2定时发送事件 (事件3)
* 一个线程3定时发送事件 (事件5)
*/
/* 指向线程控制块的指针 */
static rt_thread_t tid1 = RT_NULL;
static rt_thread_t tid2 = RT_NULL;
static rt_thread_t tid3 = RT_NULL;
/* 事件控制块 */
static struct rt_event event;
/* 线程1入口函数 */
static void thread1_entry(void *param)
{
rt_uint32_t e;
while (1)
{
/* 以逻辑与的方式接收事件 */
if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
RT_EVENT_FLAG_AND | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &e) == RT_EOK)
{
rt_kprintf("thread1: AND recv event 0x%x\n", e);
}
rt_kprintf("thread1: delay 1s to prepare second event\n");
rt_thread_delay(1000);
/* 以逻辑或的方式接收事件 */
if (rt_event_recv(&event, ((1 << 3) | (1 << 5)),
RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR,
RT_WAITING_FOREVER, &e) == RT_EOK)
{
rt_kprintf("thread1: OR recv event 0x%x\n", e);
}
rt_thread_delay(5);
}
}
/* 线程2入口函数 */
static void thread2_entry(void *param)
{
/* 线程2持续地发送事件#3 */
while (1)
{
rt_kprintf("thread2: send event1\n");
rt_event_send(&event, (1 << 3));
rt_thread_delay(10);
}
}
/* 线程3入口函数 */
static void thread3_entry(void *param)
{
/* 线程3持续地发送事件#5 */
while (1)
{
rt_kprintf("thread3: send event2\n");
rt_event_send(&event, (1 << 5));
rt_thread_delay(20);
}
}
/* USER CODE END 0 */
int main(void)
{
/* USER CODE BEGIN 1 */
/* USER CODE END 1 */
/* MCU Configuration----------------------------------------------------------*/
///* Reset of all peripherals, Initializes the Flash interface and the Systick. */
//HAL_Init();
///* USER CODE BEGIN Init */
///* USER CODE END Init */
///* Configure the system clock */
//SystemClock_Config();
///* USER CODE BEGIN SysInit */
///* USER CODE END SysInit */
///* Initialize all configured peripherals */
//MX_GPIO_Init();
//MX_USART1_UART_Init();
/* USER CODE BEGIN 2 */
/* 初始化事件对象 */
rt_event_init(&event, "event", RT_IPC_FLAG_FIFO);
/* 创建线程1 */
tid1 = rt_thread_create("t1",
thread1_entry, /* 线程入口是thread1_entry */
RT_NULL, /* 入口参数是RT_NULL */
512,
2,
20);
if (tid1 != RT_NULL)
rt_thread_startup(tid1);
/* 创建线程2 */
tid2 = rt_thread_create("t2",
thread2_entry, /* 线程入口是thread2_entry */
RT_NULL, /* 入口参数是RT_NULL */
512,
2,
20);
if (tid2 != RT_NULL)
rt_thread_startup(tid2);
/* 创建线程3 */
tid3 = rt_thread_create("t3",
thread3_entry, /* 线程入口是thread3_entry */
RT_NULL, /* 入口参数是RT_NULL */
512,
2,
20);
if (tid3 != RT_NULL)
rt_thread_startup(tid3);
rt_hw_delay_Init();
printf("\r\n机智云只为智能硬件而生\r\n");
printf("Gizwits Smart Cloud for Smart Products\r\n");
printf("链接|增值|开放|中立|安全|自有|自由|生态\r\n");
printf("www.gizwits.com\r\n");
printf("\r\nGokit RT-Thread Demo\r\n\r\n");
return 0;
/* USER CODE END 2 */
/* Infinite loop */
/* USER CODE BEGIN WHILE */
//while (1)
//{
/* USER CODE END WHILE */
/* USER CODE BEGIN 3 */
//
//}
/* USER CODE END 3 */
}
/** System Clock Configuration
*/
void SystemClock_Config(void)
{
RCC_OscInitTypeDef RCC_OscInitStruct;
RCC_ClkInitTypeDef RCC_ClkInitStruct;
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
RCC_OscInitStruct.HSEState = RCC_HSE_ON;
RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
RCC_OscInitStruct.HSIState = RCC_HSI_ON;
RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
/**Initializes the CPU, AHB and APB busses clocks
*/
RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
|RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;
if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
{
_Error_Handler(__FILE__, __LINE__);
}
/**Configure the Systick interrupt time
*/
HAL_SYSTICK_Config(HAL_RCC_GetHCLKFreq()/1000);
/**Configure the Systick
*/
HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
/* SysTick_IRQn interrupt configuration */
HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}
/* USER CODE BEGIN 4 */
/* USER CODE END 4 */
/**
* @briefThis function is executed in case of error occurrence.
* @paramNone
* @retval None
*/
void _Error_Handler(char * file, int line)
{
/* USER CODE BEGIN Error_Handler_Debug */
/* User can add his own implementation to report the HAL error return state */
while(1)
{
}
/* USER CODE END Error_Handler_Debug */
}
#ifdef USE_FULL_ASSERT
/**
* @brief Reports the name of the source file and the source line number
* where the assert_param error has occurred.
* @param file: pointer to the source file name
* @param line: assert_param error line source number
* @retval None
*/
void assert_failed(uint8_t* file, uint32_t line)
{
/* USER CODE BEGIN 6 */
/* User can add his own implementation to report the file name and line number,
ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
/* USER CODE END 6 */
}
#endif
/**
* @}
*/
/**
* @}
*/
/******** (C) COPYRIGHT STMicroelectronics **END OF FILE**/
串口信息如下：
源码下载：
iot开发平台
页:
[1]