scheduler.c

Go to the documentation of this file.

 
/* Includes ------------------------------------------------------------------*/
#include "scheduler.h"
#include "rtc.h"
 
/* Private variables ---------------------------------------------------------*/
Scheduler_t scheduler;
 
/* Private function prototypes -----------------------------------------------*/
void Scheduler_ProcessRemainingTime(const uint32_t elapsedTime);
 
void SchedulerInit(void)
{
    scheduler.startTime = 0U;
    scheduler.isRunning = 0U;
    scheduler.numOfJobs = 0U;
}
 
uint8_t SchedulerAddJob(const uint32_t period, const Callback_t callback)
{
    uint8_t result = 0U;
 
    assert_param(period > 0U);
    assert_param(callback != NULL);
 
    if(scheduler.isRunning == 0U)
    {
        if(scheduler.numOfJobs < MAX_NUM_OF_JOBS)
        {
            scheduler.jobs[scheduler.numOfJobs].period        = period;
            scheduler.jobs[scheduler.numOfJobs].remainingTime = period;
            scheduler.jobs[scheduler.numOfJobs].isPending     = 0U;
            scheduler.jobs[scheduler.numOfJobs].callback      = callback;
            ++scheduler.numOfJobs;
        }
        else
        {
            result = 0U;
        }
    }
    else
    {
        result = 0U;
    }
 
    return result;
}
 
void SchedulerProcess(void)
{
    uint8_t isScheduleNextJob = 0U;
 
    if(scheduler.isRunning != 0U)
    {
        const uint32_t elapsedTime = RtcGetEpoch() - scheduler.startTime;
        if(elapsedTime > 0U)
        {
            /* Process the remaining time of the jobs */
            Scheduler_ProcessRemainingTime(elapsedTime);
 
            /* Schedule next job */
            isScheduleNextJob = 1U;
        }
        else
        {
            /* Elapsed time is zero: no need to process and schedule jobs */
            isScheduleNextJob = 0U;
        }
    }
    else
    {
        /* Scheduler is not running: start the scheduler */
        isScheduleNextJob = 1U;
    }
 
    /* Schedule next job */
    if(isScheduleNextJob != 0U)
    {
        /* Search for the next job with the lowest remaining time */
        uint8_t indexOfNextJob = 0;
        for(uint_fast8_t i = 0U; i < scheduler.numOfJobs; ++i)
        {
            if(scheduler.jobs[i].remainingTime <
               scheduler.jobs[indexOfNextJob].remainingTime)
            {
                indexOfNextJob = i;
            }
        }
 
        /* Set RTC alarm for next job */
        if(scheduler.jobs[indexOfNextJob].remainingTime > 0U)
        {
            scheduler.startTime = RtcGetEpoch();
            if(RtcSetAlarmFromEpoch(
                   scheduler.startTime +
                   scheduler.jobs[indexOfNextJob].remainingTime) != 0U)
            {
                scheduler.isRunning = 1U;
            }
        }
    }
}
 
void SchedulerExecutePendingJobs(void)
{
    for(uint_fast8_t i = 0U; i < scheduler.numOfJobs; ++i)
    {
        if(scheduler.jobs[i].isPending != 0U)
        {
            /* Execute job callback */
            if(scheduler.jobs[i].callback != 0U)
            {
                scheduler.jobs[i].callback();
            }
 
            /* Reset pending flag */
            scheduler.jobs[i].isPending = 0U;
        }
    }
}
 
void SchedulerStop(void)
{
    if(scheduler.isRunning != 0U)
    {
        /* Deactivate RTC alarm */
        RtcDeactivateAlarm();
 
        const uint32_t elapsedTime = RtcGetEpoch() - scheduler.startTime;
        if(elapsedTime > 0U)
        {
            /* Process the remaining time of the jobs */
            Scheduler_ProcessRemainingTime(elapsedTime);
        }
        else
        {
            /* Elapsed time is zero: no need to process and schedule jobs */
        }
 
        /* Stop the scheduler */
        scheduler.isRunning = 0U;
    }
    else
    {
        /* Scheduler is already stopped: do nothing */
    }
}
 
void Scheduler_ProcessRemainingTime(const uint32_t elapsedTime)
{
    for(uint_fast8_t i = 0U; i < scheduler.numOfJobs; ++i)
    {
        if(elapsedTime >= scheduler.jobs[i].remainingTime)
        {
            /* Job is ready: reset remaining time and set pending flag */
            scheduler.jobs[i].remainingTime = scheduler.jobs[i].period;
            scheduler.jobs[i].isPending     = 1U;
        }
        else
        {
            /* Decrease remaining time */
            scheduler.jobs[i].remainingTime -= elapsedTime;
        }
    }
}