Time-slicing for equal priority tasks in FreeRTOS - Mini Project: Build & Apply

Time-slicing for equal priority tasks

📖 Scenario: You are working with FreeRTOS, a real-time operating system used in embedded devices. You want to understand how FreeRTOS shares CPU time between tasks that have the same priority. This is called time-slicing.Imagine two simple tasks that both print messages repeatedly. You will set up these tasks and observe how FreeRTOS switches between them to give each a fair share of CPU time.

🎯 Goal: Create two tasks with the same priority in FreeRTOS. Each task will print a message in a loop. You will configure the scheduler to enable time-slicing so both tasks get CPU time fairly. Finally, you will observe the output to see the tasks alternating.

📋 What You'll Learn

Create two tasks named Task1 and Task2

Set both tasks to the same priority level tskIDLE_PRIORITY + 1

Enable time-slicing in the FreeRTOS configuration

Print messages from each task to show they run alternately

💡 Why This Matters

🌍 Real World

Time-slicing is used in embedded systems to ensure multiple tasks with the same priority get CPU time fairly, such as in sensor reading and communication tasks running together.

💼 Career

Understanding time-slicing helps embedded developers design responsive multitasking applications where tasks share CPU time predictably.

1

Create two tasks with the same priority

Write code to create two FreeRTOS tasks named Task1 and Task2. Both tasks should have the priority tskIDLE_PRIORITY + 1. Each task should run a function that prints a message identifying the task in an infinite loop with a small delay. Use xTaskCreate to create the tasks.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

int main(void) {
    // Create Task1 with priority tskIDLE_PRIORITY + 1
    // Create Task2 with priority tskIDLE_PRIORITY + 1
    // Your code here
    return 0;
}

Need a hint?

Use xTaskCreate to create each task. The priority should be tskIDLE_PRIORITY + 1 for both.

2

Enable time-slicing in FreeRTOSConfig.h

Add a configuration macro #define configUSE_TIME_SLICING 1 in your FreeRTOSConfig.h file to enable time-slicing between tasks of equal priority.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

int main(void) {
    xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    return 0;
}

// Add #define configUSE_TIME_SLICING 1 below
// Your code here

Need a hint?

In FreeRTOSConfig.h, add #define configUSE_TIME_SLICING 1 to enable time-slicing.

3

Start the scheduler to run the tasks

Add the call to vTaskStartScheduler() in main() after creating the tasks. This starts the FreeRTOS scheduler and begins running the tasks.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

#define configUSE_TIME_SLICING 1

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

int main(void) {
    xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    // Add vTaskStartScheduler() call below
    // Your code here
    return 0;
}

Need a hint?

Call vTaskStartScheduler() after creating the tasks to start running them.

4

Observe the output showing time-slicing

Run the program and observe the output printed by the two tasks. The output should alternate between Task 1 is running and Task 2 is running, showing that FreeRTOS is switching between the tasks fairly using time-slicing. Write a printf statement to print "Scheduler started, tasks are running..." before starting the scheduler.

FreeRTOS

#include "FreeRTOS.h"
#include "task.h"
#include 

#define configUSE_TIME_SLICING 1

void Task1(void *pvParameters) {
    while(1) {
        printf("Task 1 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

void Task2(void *pvParameters) {
    while(1) {
        printf("Task 2 is running\n");
        vTaskDelay(pdMS_TO_TICKS(100));
    }
}

int main(void) {
    xTaskCreate(Task1, "Task1", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    xTaskCreate(Task2, "Task2", configMINIMAL_STACK_SIZE, NULL, tskIDLE_PRIORITY + 1, NULL);
    // Add printf to show scheduler start
    // Your code here
    vTaskStartScheduler();
    return 0;
}

Need a hint?

Print the message "Scheduler started, tasks are running..." before calling vTaskStartScheduler().