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;
}

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

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;
}

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;
}

Hint

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

Practice

1. What does time-slicing mean in FreeRTOS when tasks have equal priority?

easy

A. Higher priority tasks are paused to let lower priority tasks run.

B. The CPU time is shared fairly among tasks with the same priority.

C. Tasks with equal priority run one after another without switching.

D. Only the first created task runs until it finishes.

Solution

1. Step 1: Understand time-slicing concept

   Time-slicing means the CPU divides its time between tasks that have the same priority.

2. Step 2: Apply to FreeRTOS behavior

   FreeRTOS automatically switches between equal priority tasks to share CPU time fairly.

3. Final Answer:

   The CPU time is shared fairly among tasks with the same priority. -> Option B

4. Quick Check:

   Time-slicing = fair CPU sharing [OK]

Hint: Equal priority means tasks share CPU time fairly [OK]

Common Mistakes:

• Thinking only one task runs until it finishes
• Believing tasks run sequentially without switching
• Assuming lower priority tasks pause higher priority ones

2. Which of the following is the correct way to set two tasks to have equal priority in FreeRTOS?

easy

A. xTaskCreate(task1, "Task1", 1000, NULL, 2, NULL); xTaskCreate(task2, "Task2", 1000, NULL, 2, NULL);

B. xTaskCreate(task1, "Task1", 1000, NULL, 1, NULL); xTaskCreate(task2, "Task2", 1000, NULL, 3, NULL);

C. xTaskCreate(task1, "Task1", 1000, NULL, 0, NULL); xTaskCreate(task2, "Task2", 1000, NULL, 1, NULL);

D. xTaskCreate(task1, "Task1", 1000, NULL, 5, NULL); xTaskCreate(task2, "Task2", 1000, NULL, 4, NULL);

Solution

1. Step 1: Check task priority parameters

   In FreeRTOS, the fifth parameter in xTaskCreate is the task priority.

2. Step 2: Identify equal priorities

   Both tasks have priority 2 in xTaskCreate(task1, "Task1", 1000, NULL, 2, NULL); xTaskCreate(task2, "Task2", 1000, NULL, 2, NULL);, making them equal priority tasks.

3. Final Answer:

   Both tasks have priority 2, so they have equal priority. -> Option A

4. Quick Check:

   Same priority number = equal priority [OK]

Hint: Same priority number means equal priority [OK]

Common Mistakes:

• Assigning different priority numbers to tasks
• Confusing task stack size with priority
• Using priority 0 and 1 as equal

3. Given two tasks with equal priority in FreeRTOS, what is the expected behavior when both are ready to run?

medium

A. Both tasks run simultaneously on the same CPU core.

B. One task runs to completion before the other starts.

C. The second task never runs because the first task blocks it.

D. The scheduler switches between tasks periodically to share CPU time.

Solution

1. Step 1: Understand FreeRTOS scheduling for equal priority tasks

   FreeRTOS uses time-slicing to switch between tasks of equal priority.

2. Step 2: Predict scheduler behavior

   The scheduler switches tasks periodically, giving each task CPU time in turn.

3. Final Answer:

   The scheduler switches between tasks periodically to share CPU time. -> Option D

4. Quick Check:

   Equal priority tasks share CPU via switching [OK]

Hint: Equal priority tasks get CPU time by switching [OK]

Common Mistakes:

• Thinking tasks run one after another without switching
• Assuming tasks run simultaneously on one core
• Believing one task blocks the other forever

4. You have two tasks with equal priority, but one task never seems to run. What is the most likely cause?

medium

A. The task that never runs has a higher priority number.

B. FreeRTOS does not support time-slicing for equal priority tasks.

C. The task that never runs is blocked or waiting indefinitely.

D. The scheduler is disabled, so no task switching occurs.

Solution

1. Step 1: Check task states in FreeRTOS

   Even with equal priority, a task that is blocked or waiting will not run.

2. Step 2: Identify why a task never runs

   If a task never runs, it is likely blocked or waiting indefinitely, not ready to run.

3. Final Answer:

   The task that never runs is blocked or waiting indefinitely. -> Option C

4. Quick Check:

   Blocked task = no CPU time [OK]

Hint: Blocked tasks don't get CPU time even if priority is equal [OK]

Common Mistakes:

• Assuming higher priority task blocks lower priority always
• Believing FreeRTOS lacks time-slicing
• Ignoring task states like blocked or suspended

5. You have three tasks with equal priority in FreeRTOS. Task A runs for 10ms, Task B for 20ms, and Task C for 30ms before yielding. How does time-slicing affect their CPU time distribution?

hard

A. Each task gets equal CPU time slices regardless of run duration before yielding.

B. Tasks that run longer before yielding get more CPU time overall.

C. Task C will starve Tasks A and B because it runs longest.

D. FreeRTOS runs tasks in creation order ignoring time-slicing.

Solution

1. Step 1: Understand time-slicing with equal priority tasks

   FreeRTOS scheduler switches tasks periodically to share CPU time fairly among equal priority tasks.

2. Step 2: Analyze effect of different run durations before yielding

   Even if tasks run different times before yielding, the scheduler enforces time slices to balance CPU time.

3. Final Answer:

   Each task gets equal CPU time slices regardless of run duration before yielding. -> Option A

4. Quick Check:

   Time-slicing ensures fair CPU time despite run length [OK]

Hint: Time-slicing balances CPU time regardless of task run length [OK]

Common Mistakes:

• Assuming longer running tasks get more CPU time
• Thinking tasks can starve others with longer runs
• Believing task creation order controls CPU time