In a multitasking operating system, different tasks need to run synchronously, and the semaphore function can provide users with this support. Semaphore is a mechanism for inter-task communication, enabling synchronization between tasks or mutually exclusive access to critical resources.

Semaphore is a very flexible synchronization method, can be used in a variety of occasions, to achieve lock, synchronization, resource count and other functions, also can be conveniently used for task and task, interrupt and task synchronization.

• The mutex

When used as a mutex, the semaphore is full after it is created. When critical resources need to be used, the semaphore should be applied first to make it empty. In this way, when other tasks need to use critical resources, they will be blocked because they cannot apply for the semaphore, thus ensuring the safety of critical resources.

• Inter-task synchronization

When used for synchronization, the semaphore is set to null after creation, and task 1 is blocked by applying for the semaphore. Task 2 releases the semaphore after some condition occurs, and task 1 enters the READY or RUNNING state, thus achieving synchronization between the two tasks.

• Resource count

When used as a resource count, a semaphore acts as a special counter that can increase or decrease, but can never be negative. The typical application scenario is the producer and consumer scenario.

• Interrupts synchronization with tasks

When used as the synchronization of interrupt and task, the value of semaphore can be set to 0 when the interrupt is not triggered, so as to block the interrupt service processing task. Once the interrupt is triggered, the blocked interrupt service processing task will be woken up for interrupt processing.

The osal_semp_create interface is used to create a semaphore. The interface prototype is as follows:

bool_t  osal_semp_create(osal_semp_t *semp,int limit,int initvalue)
{
    bool_t ret = false;

    if((NULL! = s_os_cb) &&(NULL! = s_os_cb->ops) &&(NULL! = s_os_cb->ops->semp_create)) { ret = s_os_cb->ops->semp_create(semp,limit,initvalue); }return ret;

}
Copy the code

The following table describes the interface parameters:

The oSAL_semp_pend interface is used to apply for a semaphore. Its interface prototype is as follows:

bool_t  osal_semp_pend(osal_semp_t semp,int timeout)
{
    bool_t ret = false;

    if((NULL! = s_os_cb) &&(NULL! = s_os_cb->ops) &&(NULL! = s_os_cb->ops->semp_pend)) { ret = s_os_cb->ops->semp_pend(semp,timeout); }return ret;

}
Copy the code

The following table describes the interface parameters:

Semaphores can be applied in three modes: non-blocking mode, permanent blocking mode, and timed blocking mode, selected using the timeout parameter.

• Non-blocking mode (0) :

A task needs to apply for a semaphore. If the number of tasks does not reach the upper limit set by the semaphore, the application is successful. Otherwise, the application fails immediately

• Permanent blocking mode (CN_OSAL_timeout_forever or 0xFFFFFFFF) :

A task needs to apply for a semaphore. If the number of tasks does not reach the upper limit set by the semaphore, the application is successful. Otherwise, the task is blocked, and the system switches to the task with the highest priority. After a task enters a blocked state, it will not resume execution until another task releases the semaphore

• Timing blocking mode (arbitrary timing, 32bit) :

A task needs to apply for a semaphore. If the number of tasks does not reach the upper limit set by the semaphore, the application is successful. Otherwise, the task is blocked, and the system switches to the task with the highest priority. After a task enters the blocked state, other tasks will release the semaphore before the specified timeout, or the blocked task will be executed again after the specified timeout

Since interrupts cannot be blocked, blocking mode cannot be used in interrupts when requesting semaphores.

First, open the HelloWorld project used in the previous article and conduct experiments based on this project.

Right-click in the Demo folder and create a new folder osal_kernel_demo to store the kernel experiment files (skip this step if you already have one).

Create a new experiment file osal_semp_demo.c in this folder and start writing code:

/* To use the osal interface, include the header */
#include <osal.h>

/* Task priority macro definition (shell task priority is 10) */
#define USER_TASK1_PRI  12  // Low priority
#define USER_TASK2_PRI  11  // High priority

/* Semaphore index ID */
osal_semp_t sync_semp;

/* Task1 entry function */
static int user_task1_entry(a)
{
    while(1)
    {
        /* Print information on the serial port */
        printf("task 1 post a semp! \r\n");

        /* Release semaphore after printing */
        osal_semp_post(sync_semp);

        /* The task actively suspends 2s */
        osal_task_sleep(2*1000); }}/* Task2 entry function */
static int user_task2_entry(a)
{
    while (1)
    {
        /* High priority, preempt to print information */
        printf("task2 is waiting for a semp... \r\n");

        /* Apply for semaphore, fail to apply, suspend wait */
        osal_semp_pend(sync_semp, cn_osal_timeout_forever);

        /* Once the semaphore is applied, the execution is resumed */
        printf("task 2 access a semp! \r\n"); }}/* Standard demo start function, do not change the function name, otherwise it will affect the next experiment */
int standard_app_demo_main(a)
{
    /* Create semaphore sync_semp */
    osal_semp_create(&sync_semp, 1.0);
    printf("sync_semp semp create success.\r\n");

    /* Create task task1 */
    osal_task_create("user_task1",user_task1_entry,NULL.0x400.NULL,USER_TASK1_PRI);

    /* Create task task2 */
    osal_task_create("user_task2",user_task2_entry,NULL.0x400.NULL,USER_TASK2_PRI);

    return 0;
}
Copy the code

After writing, add the osal_semp_demo file we wrote to the makefile and add the compilation of the entire project:

An easy way to do this is to directly modify the user_demo.mk configuration file in the Demo folder and add the following code:

	#example for osal_semp_demo
	ifeq ($(CONFIG_USER_DEMO), "osal_semp_demo")	
		user_demo_src  = ${wildcard $(TOP_DIR)/targets/STM32L431_BearPi/Demos/osal_kernel_demo/osal_semp_demo.c}
		user_demo_defs = -D CONFIG_OSAL_SEMP_DEMO_ENABLE=1
	endif
Copy the code

Add location as shown below:

This code means:

If the CONFIG_USER_DEMO macro defines a value of osal_semp_demo, then the osal_semp_demo.c file is added to the makefile for compilation.

So how do you configure the CONFIG_USER_DEMO macro definition? At the end of the. Sdkconfig file in the project root directory:

Because we modified the MK configuration file, click the recompile buttonAfter compiling, click the download button to burn the program.

After compiling, there is a warning that user_task1_entry and user_task2_entry do not return a value. While (1) does not return, so ignore it.