Scheduler.h File Reference

#include "../Utils/Updateable.h"
#include "Task.h"

Include dependency graph for Scheduler.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	Scheduler

Macros
#define	MAX_SENSORS   32
#define	MAX_HZ   1000

Functions
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)

Macro Definition Documentation

MAX_HZ

#define MAX_HZ   1000

Definition at line 8 of file Scheduler.h.

MAX_SENSORS

#define MAX_SENSORS   32

Definition at line 7 of file Scheduler.h.

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];
        snprintf(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);
}