FreeRTOS has two definitions for the port-specific data type: TickType_t and BaseType_t in the portmacro.h header file.

The following flowchart shows how to create a simple FreeRTOS-based application.

In the main() function:

1. FreeRTOS_Init(): Initializes the interrupt vector table for FreeRTOS.
2. MyPSoCSetup(): Initializes the PSoC components and global variables
3. xTaskCreate(...): Creates a new instance of a task
4. vTaskStartScheduler(): Starts the FreeRTOS scheduler running. If all is well, the scheduler will be running, and the next infinite loop will never be reached
5. Infinite loop: If this code is executed, that means that there was insufficient FreeRTOS heap memory available for the idle and/or timer tasks to be created

Example FreeRTOS code

#include <project.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <stdbool.h>

// FreeRTOS Header Files
#include "FreeRTOS_PSoC.h"
#include "FreeRTOS.h"
#include "task.h"
#include "queue.h"
#include "semphr.h"
#include "timers.h"
#include "event_groups.h"

// Your Task Functions
void vAppTask( void *pvParameters );

//------------------------------------------------------------------------------
void MyPSoCSetup( void )
{
	/* Start-up the peripherals. */

	/* Enable and clear the LCD Display. */
    LCD_Start();
	LCD_ClearDisplay();
	LCD_PrintString( "AirSupplyLab" );
}
//------------------------------------------------------------------------------
int main( void )
{
    BaseType_t  err;

    FreeRTOS_Init();
    /* Place your initialization/startup code here (e.g. MyInst_Start()) */
	MyPSoCSetup();

    /* --- APPLICATION TASKS CAN BE CREATED HERE --- */
    err = xTaskCreate(
        vAppTask,                   // Pointer to the function that implements the task
        "Task 1",                   // Text name for the task. This is to facilitate debugging only
        configMINIMAL_STACK_SIZE,   // Stack depth - small microcontrollers will use much less stack than this
        NULL,                       // Task parameter
        5,                          // Task priority
        NULL);                      // Task handle

    if (err != pdPASS){
        LCD_Position(1,0);
        LCD_PrintString("Cannot create task!");
        while(1){};
    }
    /* Start the scheduler so the tasks start executing. */
	vTaskStartScheduler();

    /* Execution will only reach here if there was insufficient heap to start the scheduler. */
	/* Should never reach here as the kernel will now be running.  If
	vTaskStartScheduler() does return then it is very likely that there was
	insufficient (FreeRTOS) heap space available to create all the tasks,
	including the idle task that is created within vTaskStartScheduler() itself. */
	for( ;; ){
        vTaskDelay(1000);
    }
}
//------------------------------------------------------------------------------
void vAppTask(void *pvParameters)
{
    for(;;){
        LED_Write( !LED_Read());
        vTaskDelay(pdMS_TO_TICKS(500));    // Delay for 500ms
    }
}

FreeRTOS requires memory. The amount of memory required and how to manage that memory varies per application. To allow for this variation, FreeRTOS implements several different memory management schemes. These are implemented in source files named heap_1.c, heap_2.c, up through heap_5.c.

The memory management schemes included in FreeRTOS:

• heap_1 - the very simplest, does not permit memory to be freed.
• heap_2 - allows memory to be free but does not coalesce adjacent free blocks.
• heap_3 - simply wraps the standard malloc() and free() for thread safety.
• heap_4 - coalesces adjacent free blocks to avoid fragmentation. Includes absolute address placement option.
• heap_5 - as per heap_4, with the ability to span the heap across multiple non-adjacent memory areas.

The startup code for the compiler will bring the CPU to the main() function, which is the entry point for the application. In the main() function, you need to initialize the operating system, create the primary application task (App_TaskStart() function), begin multitasking.

Listing 1: main.c Code

int  main (void)
{
    OS_ERR  os_err;

    BSP_PreInit();                                              // Perform BSP pre-initialization

    CPU_Init();                                                 // Initialize the uC/CPU services

    OSInit(&os_err);                                            // Init uC/OS-III

    OSTaskCreate((OS_TCB      *)&App_TaskStartTCB,              // Create the start task
                 (CPU_CHAR    *)"Start",
                 (OS_TASK_PTR  )App_TaskStart,
                 (void        *)0,
                 (OS_PRIO      )APP_CFG_TASK_START_PRIO,
                 (CPU_STK     *)&App_TaskStartStk[0],
                 (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE_LIMIT,
                 (CPU_STK_SIZE )APP_CFG_TASK_START_STK_SIZE,
                 (OS_MSG_QTY   )0u,
                 (OS_TICK      )0u,
                 (void        *)0,
                 (OS_OPT       )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR      *)&os_err);

    OSStart(&os_err);                                            // Start multitasking (i.e. give control to uC/OS-III)
}

• Line 5: BSP_PreInit()
  It is a Board Support Package pre-initialization function. This function will perform all the hardware initialization required before the OS is initialized. Most of the time, this function will disable all interrupts to make sure the application does not get interrupted until it is fully initialized.
• Line 7: CPU_Init()
  Initializes μC/CPU. μC/CPU contains CPU-related code to enable/disable interrupts and enter/exit to/from critical sections, among other functions.
• Line 9: OSInit()
  Initialize the μC/OS-III. This function must be called before creating a task or any other kernel object.
• Line 11: OSTaskCreate()
  At least one task must be created. OSTaskCreate() will create the startup task.
• Line 25: OSStart()
  You need to call this function to let μC/OS-III start the multitasking and give control to μC/OS-III. At this point, there should be either 4 to 6 tasks created depending on configuration option: OS_IdleTask(), OS_TickTask(), OS_StatTask(), OS_TmrTask() (optional), OS_IntQTask() (optional) and now AppTaskStart().

• Line 1: We will be creating an application task, and it is necessary to allocate a task control block (OS_TCB) for this task
• Line 2: Each task created requires its own stack. A stack must be declared using the CPU_STK data type as shown. The stack can be allocated statically, as shown here, or dynamically from the heap using malloc().

The listing below shows how to create other tasks once multitasking has started.

static  void  App_TaskCreate (void)
{
    OS_ERR  err;

    OSTaskCreate((OS_TCB      *)&AppTask1_TCB,
                 (CPU_CHAR    *)"App Task 1",
                 (OS_TASK_PTR  )AppTask1,
                 (void        *)0,
                 (OS_PRIO      )5,
                 (CPU_STK     *)&AppTask1_Stk[0],
                 (CPU_STK_SIZE )0,
                 (CPU_STK_SIZE )128,
                 (OS_MSG_QTY   )0,
                 (OS_TICK      )0,
                 (void        *)0,
                 (OS_OPT       )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR      *)&err);

    OSTaskCreate((OS_TCB      *)&AppTask2_TCB,
                 (CPU_CHAR    *)"App Task 2",
                 (OS_TASK_PTR  )AppTask2,
                 (void        *)0,
                 (OS_PRIO      )6,
                 (CPU_STK     *)&AppTask2_Stk[0],
                 (CPU_STK_SIZE )0,
                 (CPU_STK_SIZE )128,
                 (OS_MSG_QTY   )0,
                 (OS_TICK      )0,
                 (void        *)0,
                 (OS_OPT       )(OS_OPT_TASK_STK_CHK | OS_OPT_TASK_STK_CLR),
                 (OS_ERR      *)&err);
}

In the PSoC Creator, the interrupts are managed by the Interrupt component . To integrate the interrupt with μC/OS-III, the following code must be added to the Interrupt Service Routine (ISR) code.

Cy_ISR( MyISR )
{
    CPU_SR_ALLOC();
    CPU_CRITICAL_ENTER();
    OSIntEnter();
    CPU_CRITICAL_EXIT();

    // Your ISR Code Here

    OSIntExit();
}

• Line 3: CPU_SR_ALLOC()
  This function allocates storage for a local variable to hold the value of the current interrupt disable status of the CPU.
• Line 5: OSIntEnter()
  Notify μC/OS-III that an ISR is being processed, which allows μC/OS-III to keep track of interrupt nesting.
• Line 10: OSIntExit()
  Notify μC/OS-III that the ISR is complete, which allows μC/OS-III to keep track of track of interrupt nesting. When the last nested interrupt completes OSIntExit() determines if a higher priority task is ready to run. If so, the interrupt return to the higher priority task instead of the interrupt task.

Your text...