Scheduler.c File Reference

#include "FreeRTOS.h"
#include "task.h"
#include "timers.h"
#include "queue.h"
#include "../../Inc/Scheduler/Scheduler.h"

Include dependency graph for Scheduler.c:

Go to the source code of this file.

Classes
struct	ScheduledUpdateable
struct	WorkItem

Macros
#define	WORK_QUEUE_SIZE   32
#define	WORKER_STACK_SIZE   1024
#define	WORKER_PRIORITY   (tskIDLE_PRIORITY + 2)

Functions
static void	workerTask (void *pvParameters)
static void	updateableTimerCallback (TimerHandle_t xTimer)
void	SchedulerInit (Scheduler *scheduler, Updateable *updatableArray[])
void	SchedulerRun (Scheduler *scheduler)
void	SchedulerStop (Scheduler *scheduler)
void	SchedulerSuspendUpdateable (const char *name)
void	SchedulerResumeUpdateable (const char *name)
void	SchedulerGetStats (void)
void	SchedulerCleanup (void)

Variables
static ScheduledUpdateable	scheduledTasks [MAX_SENSORS]
static int	taskCount = 0
static TaskHandle_t	workerTaskHandle = NULL
static QueueHandle_t	workQueue = NULL

Macro Definition Documentation

WORK_QUEUE_SIZE

#define WORK_QUEUE_SIZE   32

Definition at line 25 of file Scheduler.c.

WORKER_PRIORITY

#define WORKER_PRIORITY   (tskIDLE_PRIORITY + 2)

Definition at line 27 of file Scheduler.c.

WORKER_STACK_SIZE

#define WORKER_STACK_SIZE   1024

Definition at line 26 of file Scheduler.c.

Function Documentation

SchedulerCleanup()

void SchedulerCleanup

(

void

)

Definition at line 225 of file Scheduler.c.

                            {
    // Delete worker task
    if (workerTaskHandle != NULL) {
        vTaskDelete(workerTaskHandle);
        workerTaskHandle = NULL;
    }
    
    // Delete work queue
    if (workQueue != NULL) {
        vQueueDelete(workQueue);
        workQueue = NULL;
    }
    
    // Delete all timers
    for (int i = 0; i < taskCount; i++) {
        if (scheduledTasks[i].timer != NULL) {
            xTimerDelete(scheduledTasks[i].timer, portMAX_DELAY);
            scheduledTasks[i].timer = NULL;
        }
    }
    
    taskCount = 0;
    //printf("Scheduler cleaned up\n");
}

SchedulerGetStats()

void SchedulerGetStats

(

void

)

Definition at line 202 of file Scheduler.c.

                             {
    UBaseType_t queueLength = uxQueueMessagesWaiting(workQueue);
    UBaseType_t queueSpaces = uxQueueSpacesAvailable(workQueue);
    
    //printf("Scheduler Statistics:\n");
    //printf("- Active timers: %d\n", taskCount);
    //printf("- Work queue: %lu items pending, %lu spaces available\n", 
    //       queueLength, queueSpaces);
    
    if (workerTaskHandle != NULL) {
        TaskStatus_t taskStatus;
        vTaskGetInfo(workerTaskHandle, &taskStatus, pdTRUE, eInvalid);
        //printf("- Worker task stack high water mark: %u words\n", 
        //       taskStatus.usStackHighWaterMark);
    }
    
    if (queueLength > (WORK_QUEUE_SIZE * 3 / 4)) {
        //printf("WARNING: Work queue is %lu%% full - worker may be overloaded\n",
        //       (queueLength * 100) / WORK_QUEUE_SIZE);
    }
}

SchedulerInit()

void SchedulerInit	(	Scheduler *	scheduler,
		Updateable *	updatableArray[]
	)

Definition at line 80 of file Scheduler.c.

                                                                       {
    scheduler->running = 0;
    taskCount = 0;
 
    // Create work queue for communicating between timer callbacks and worker task
    workQueue = xQueueCreate(WORK_QUEUE_SIZE, sizeof(WorkItem));
    if (workQueue == NULL) {
        //printf("ERROR: Failed to create work queue\n");
        return;
    }
 
    // Create worker task to handle updateables
    if (xTaskCreate(workerTask, "SchedulerWorker", WORKER_STACK_SIZE, NULL, 
                    WORKER_PRIORITY, &workerTaskHandle) != pdPASS) {
        //printf("ERROR: Failed to create worker task\n");
        return;
    }
 
    //printf("Created scheduler worker task\n");
 
    // Create timers for each updateable
    for (int i = 0; updatableArray[i] != NULL && i < MAX_SENSORS; i++) {
        Updateable* updateable = updatableArray[i];
        
        if (updateable->hz <= 0 || updateable->hz > MAX_HZ) {
            //printf("Warning: Skipping %s - invalid frequency %d Hz\n", 
            //       updateable->name, updateable->hz);
            continue;
        }
 
        // Calculate period in FreeRTOS ticks
        TickType_t period = pdMS_TO_TICKS(1000 / updateable->hz);
        if (period == 0) period = 1; // Minimum 1 tick for 1kHz tasks
        
        // Create timer name
        char timerName[32];
        //printf(timerName, sizeof(timerName), "T_%s", updateable->name);
        
        // Create FreeRTOS software timer
        TimerHandle_t timer = xTimerCreate(
            timerName,                     // Timer name
            period,                        // Period in ticks
            pdTRUE,                       // Auto-reload (periodic)
            updateable,                   // Timer ID
            updateableTimerCallback       // Callback function
        );
        
        if (timer != NULL) {
            scheduledTasks[taskCount].updateable = updateable;
            scheduledTasks[taskCount].timer = timer;
            taskCount++;
            
            //printf("Created timer: %s at %dHz (period: %lu ticks)\n", 
            //       updateable->name, updateable->hz, period);
        } else {
            //printf("ERROR: Failed to create timer for %s\n", updateable->name);
        }
    }
    
    //printf("Scheduler initialized with %d timers and worker task\n", taskCount);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SchedulerResumeUpdateable()

void SchedulerResumeUpdateable

(

const char *

name

)

Definition at line 189 of file Scheduler.c.

                                                 {
    for (int i = 0; i < taskCount; i++) {
        if (scheduledTasks[i].updateable && 
            strcmp(scheduledTasks[i].updateable->name, name) == 0) {
            if (xTimerStart(scheduledTasks[i].timer, 0) == pdPASS) {
                //printf("Resumed timer for %s\n", name);
                return;
            }
        }
    }
    //printf("Warning: Could not find or resume timer for %s\n", name);
}

SchedulerRun()

void SchedulerRun

(

Scheduler *

scheduler

)

Definition at line 142 of file Scheduler.c.

                                        {
    scheduler->running = 1;
    
    // Start all timers
    int started = 0;
    for (int i = 0; i < taskCount; i++) {
        if (xTimerStart(scheduledTasks[i].timer, 0) == pdPASS) {
            started++;
        } else {
            //printf("ERROR: Failed to start timer for %s\n", 
            //       scheduledTasks[i].updateable->name);
        }
    }
    
    //printf("Started %d/%d timers\n", started, taskCount);
    
    // Start FreeRTOS scheduler
    vTaskStartScheduler();
}

Here is the caller graph for this function:

SchedulerStop()

void SchedulerStop

(

Scheduler *

scheduler

)

Definition at line 162 of file Scheduler.c.

                                         {
    scheduler->running = 0;
    
    // Stop all timers
    for (int i = 0; i < taskCount; i++) {
        if (scheduledTasks[i].timer != NULL) {
            xTimerStop(scheduledTasks[i].timer, portMAX_DELAY);
        }
    }
    
    //printf("All timers stopped\n");
}

SchedulerSuspendUpdateable()

void SchedulerSuspendUpdateable

(

const char *

name

)

Definition at line 176 of file Scheduler.c.

                                                  {
    for (int i = 0; i < taskCount; i++) {
        if (scheduledTasks[i].updateable && 
            strcmp(scheduledTasks[i].updateable->name, name) == 0) {
            if (xTimerStop(scheduledTasks[i].timer, 0) == pdPASS) {
                //printf("Suspended timer for %s\n", name);
                return;
            }
        }
    }
    //printf("Warning: Could not find or suspend timer for %s\n", name);
}

updateableTimerCallback()

static void updateableTimerCallback ( TimerHandle_t  xTimer )

static

Definition at line 59 of file Scheduler.c.

                                                          {
    Updateable* updateable = (Updateable*)pvTimerGetTimerID(xTimer);
    
    if (updateable != NULL && workQueue != NULL) {
        WorkItem workItem = {
            .updateable = updateable,
            .timestamp = xTaskGetTickCount()
        };
        
        // Send to worker task (non-blocking from timer context)
        BaseType_t xHigherPriorityTaskWoken = pdFALSE;
        if (xQueueSendFromISR(workQueue, &workItem, &xHigherPriorityTaskWoken) != pdTRUE) {
            // Queue full - this indicates the worker task is overloaded
            //printf("ERROR: Work queue full for %s - dropping task\n", updateable->name);
        }
        
        // Yield if higher priority task was woken
        portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
    }
}

Here is the caller graph for this function:

workerTask()

static void workerTask ( void *  pvParameters )

static

Definition at line 30 of file Scheduler.c.

                                           {
    WorkItem workItem;
    
    while (1) {
        // Wait for work items from timer callbacks
        if (xQueueReceive(workQueue, &workItem, portMAX_DELAY) == pdTRUE) {
            if (workItem.updateable != NULL) {
                // Record start time for performance monitoring
                TickType_t startTime = xTaskGetTickCount();
                
                // Execute the updateable
                Task task;
                TaskInit(&task, workItem.updateable, workItem.updateable->hz);
                TaskExecute(&task);
                
                // Check execution time
                TickType_t executionTime = xTaskGetTickCount() - startTime;
                TickType_t maxTime = pdMS_TO_TICKS(1000 / workItem.updateable->hz) / 2; // 50% of period
                
                if (executionTime > maxTime) {
                    //printf("WARNING: %s took %lu ticks (max recommended: %lu)\n", 
                    //       workItem.updateable->name, executionTime, maxTime);
                }
            }
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

scheduledTasks

ScheduledUpdateable scheduledTasks[MAX_SENSORS]

static

Definition at line 18 of file Scheduler.c.

taskCount

int taskCount = 0

static

Definition at line 19 of file Scheduler.c.

workerTaskHandle

TaskHandle_t workerTaskHandle = NULL

static

Definition at line 22 of file Scheduler.c.

workQueue

QueueHandle_t workQueue = NULL

static

Definition at line 23 of file Scheduler.c.