STM32 uCOS_II practice event identification group

At this point, you should have a certain understanding of the operation process of ucos. For the process of semaphore transmission, you can refer to another post. Here we only focus on the event identification group itself.

First, applying event identification groups requires four steps:

1. Declare a pointer variable to identify the group.

   void *SemGrp_Task_LED1;

   This stores the pointer to the event control block, and is a global variable that needs to be globally declared (extern) in the corresponding header file. When the identification group is initialized, the event control block is initialized. The event control block is the module for managing and allocating this resource.

2. Initialize the event identification group,

   SemGrp_Task_LED1 = OSFlagCreate(0,&err);

   Parameter 0 is the result of the final logic operation, the initial value is 0, and parameter &err is the error message;

3. Set the waiting function in the user task,

   OSFlagPend( SemGrp_Task_LED1, // Flag group pointer
                0x03, // Flag is the last two digits
         OS_FLAG_WAIT_SET_ALL + OS_FLAG_CONSUME, // Set and operate and clear the flag after the operation
         0,&err // No wait timeout
                );

   There are 5 parameters in total. The first parameter sets the identification group pointer, indicating which identification group is being waited for; the second parameter is which operation bits are in the identification group. 0x03 means that there are 2 semaphores participating in this group and they are the lowest two bits of a byte; the third parameter is the combination of these semaphores to form a valid message, which is the two operations of "AND" and "OR", that is, all single semaphores are triggered when they are 1 or as long as one semaphore sends 1, and the corresponding operation relationship is to clear the single semaphore after the operation; the fourth parameter is the waiting time, the unit is the number of system heartbeats, and 0 means waiting without time limit; the fifth parameter is the error type.

4. Set the sending semaphore function in different user tasks or trigger tasks.

   OSFlagPost(SemGrp_Task_LED1,0x01,OS_FLAG_SET,&err); // Set the first bit of the group flag

   There are four parameters in total. The first parameter is the identification group pointer, which indicates which identification group you are sending to; the second parameter indicates the number of bits you are operating on. The specific valid bit is set in the waiting function. In the sending function, it indicates which bit you are sending in the waiting function. In the code example, it is the lowest bit sent; the third parameter is whether to set it to one or zero, OS_FLAG_SET is set to one, and OS_FLAG_CLR is cleared to zero; the fourth parameter is the error type.

================================================== ===================================

    Here is the actual code inside the system:

    Step 2 and Step 3

   Two step 4 functions, respectively in the external interrupt service function:

void Interrupt_Handle_KEY2(void)
{
OSIntEnter();

// If you call the ucos system function in the interrupt service function, you must add the interrupt system function when you enter and exit the interrupt system function.

OSFlagPost(SemGrp_Task_LED1,0x01,OS_FLAG_SET,&err); // Set the first bit of the group flag EXTI_ClearITPendingBit
(EXTI_Line4); // Clear the flag bit

OSIntExit();
}

void Interrupt_Handle_KEY3(void)
{
OSIntEnter();

// If you call the ucos system function in the interrupt service function, you must add the interrupt system function when you enter and exit the interrupt system function.

OSFlagPost(SemGrp_Task_LED1,0x02,OS_FLAG_SET,&err); // Set the second bit of the group flag
EXTI_ClearITPendingBit(EXTI_Line3); // Clear the flag bit

OSIntExit();
}

Summarize:

      For the operation of event identification group, the idea is very simple. Add a waiting function in a task of the final result. When the system runs here, it will suspend this task, and then wait for each single semaphore according to the logic. There is a sending function in other tasks. According to the operation bit set in the waiting function, each bit is set high or low, so as to achieve the purpose of synchronizing multiple tasks with one task.