Simple round-robbin pseudo-task scheduler. More...

Data Structures
struct	TaskEntry_t
	Scheduler Task List Entry Structure. More...
Defines
#define	TASK(name) void name (void)
#define	TASK_LIST TaskEntry_t Scheduler_TaskList[] =
#define	TASK_MAX_DELAY (MAX_DELAYCTR_COUNT - 1)
#define	TASK_RUN true
#define	TASK_STOP false
Typedefs
typedef void(*	TaskPtr_t )(void)
typedef uint_least16_t	SchedulerDelayCounter_t
Functions
void	Scheduler_Start (void)
void	Scheduler_Init (void)
static void	Scheduler_ResetDelay (SchedulerDelayCounter_t *const DelayCounter) ATTR_NON_NULL_PTR_ARG(1) ATTR_ALWAYS_INLINE
bool	Scheduler_HasDelayElapsed (const uint_least16_t Delay, SchedulerDelayCounter_t *const DelayCounter) ATTR_WARN_UNUSED_RESULT ATTR_NON_NULL_PTR_ARG(2)
void	Scheduler_SetTaskMode (const TaskPtr_t Task, const bool TaskStatus)
void	Scheduler_SetGroupTaskMode (const uint_least8_t GroupID, const bool TaskStatus)
Variables
TaskEntry_t	Scheduler_TaskList []
volatile uint_least8_t	Scheduler_TotalTasks
volatile SchedulerDelayCounter_t	Scheduler_TickCounter

Detailed Description

Deprecated:: This module is deprecated and will be removed in a future library release.

Module Source Dependencies

The following files must be built with any user project that uses this module:

LUFA/Scheduler/Scheduler.c (Makefile source module name: LUFA_SRC_SCHEDULER)

Module Description

Simple round-robbin cooperative scheduler for use in basic projects where non real-time tasks need to be executed. Each task is executed in sequence, and can be enabled or disabled individually or as a group.

For a task to yield it must return, thus each task should have persistent data marked with the static keyword.

Each LUFA scheduler task should be written similar to an ISR; it should execute quickly (so that no one task hogs the processor, preventing another from running before some sort of timeout is exceeded). Unlike normal RTOS tasks, each LUFA scheduler task is a regular function, and thus must be designed to be called, and designed to return to the calling scheduler function repeatedly. Data which must be preserved between task calls should be declared as global or (preferably) as a static local variable inside the task.

The scheduler consists of a task list, listing all the tasks which can be executed by the scheduler. Once started, each task is then called one after another, unless the task is stopped by another running task or interrupt.

Usage Example:

      #include <LUFA/Scheduler/Scheduler.h>

      TASK(MyTask1); // Task prototype
      TASK(MyTask2); // Task prototype

      TASK_LIST
      {
          { .Task = MyTask1, .TaskStatus = TASK_RUN, .GroupID = 1  },
          { .Task = MyTask2, .TaskStatus = TASK_RUN, .GroupID = 1  },
      }

      int main(void)
      {
          Scheduler_Init();

          // Other initialisation here

          Scheduler_Start();
      }

      TASK(MyTask1)
      {
          // Task implementation here
      }

      TASK(MyTask2)
      {
          // Task implementation here
      }

If desired, the LUFA scheduler does not need to be used in a LUFA powered application. A more conventional approach to application design can be used, or a proper scheduling RTOS inserted in the place of the LUFA scheduler. In the case of the former the USB task must be run manually repeatedly to maintain USB communications, and in the case of the latter a proper RTOS task must be set up to do the same.

Define Documentation

#define TASK ( name ) void name (void)

Creates a new scheduler task body or prototype. Should be used in the form:

      TASK(TaskName); // Prototype

      TASK(TaskName)
      {
           // Task body
      }

#define TASK_LIST TaskEntry_t Scheduler_TaskList[] =

Defines a task list array, containing one or more task entries of the type TaskEntry_t. Each task list should be encased in curly braces and ended with a comma.

Usage Example:

      TASK_LIST
      {
           { .Task = MyTask1, .TaskStatus = TASK_RUN, .GroupID = 1 },
           // More task entries here
      }

#define TASK_MAX_DELAY (MAX_DELAYCTR_COUNT - 1)

Constant, giving the maximum delay in scheduler ticks which can be stored in a variable of type SchedulerDelayCounter_t.

#define TASK_RUN true

Task status mode constant, for passing to Scheduler_SetTaskMode() or Scheduler_SetGroupTaskMode().

#define TASK_STOP false

Task status mode constant, for passing to Scheduler_SetTaskMode() or Scheduler_SetGroupTaskMode().

Typedef Documentation

typedef uint_least16_t SchedulerDelayCounter_t

Type define for a variable which can hold a tick delay value for the scheduler up to the maximum delay possible.

typedef void(* TaskPtr_t)(void)

Type define for a pointer to a scheduler task.

Function Documentation

bool Scheduler_HasDelayElapsed	(	const uint_least16_t	Delay,
		SchedulerDelayCounter_t *const	DelayCounter
	)

Determines if the given tick delay has elapsed, based on the given delay period and tick counter value.

Parameters:

[in]	Delay	The delay to test for, measured in ticks.
[in]	DelayCounter	The counter which is storing the starting tick value for the delay.

Returns:: Boolean true if the delay has elapsed, false otherwise.

Usage Example:

      static SchedulerDelayCounter_t DelayCounter = 10000; // Force immediate run on start-up

      // Task runs every 10000 ticks, 10 seconds for this demo
      if (Scheduler_HasDelayElapsed(10000, &DelayCounter))
      {
           // Code to execute after delay interval elapsed here
      }

void Scheduler_Init ( void )

Initialises the scheduler so that the scheduler functions can be called before the scheduler itself is started. This must be executed before any scheduler function calls other than Scheduler_Start(), and can be omitted if no such functions could be called before the scheduler is started.

static void Scheduler_ResetDelay ( SchedulerDelayCounter_t *const DelayCounter ) [inline, static]

Resets the delay counter value to the current tick count. This should be called to reset the period for a delay in a task which is dependant on the current tick value.

Parameters:

[out] DelayCounter Counter which is storing the starting tick count for a given delay.

void Scheduler_SetGroupTaskMode	(	const uint_least8_t	GroupID,
		const bool	TaskStatus
	)

Sets the task mode for a given task group ID, allowing for an entire group of tasks to have their statuses changed at once.

Parameters:

[in]	GroupID	Value of the task group ID whose status is to be changed.
[in]	TaskStatus	New task status for tasks in the specified group (TASK_RUN or TASK_STOP).

void Scheduler_SetTaskMode	(	const TaskPtr_t	Task,
		const bool	TaskStatus
	)

Sets the task mode for a given task.

Parameters:

[in]	Task	Name of the task whose status is to be changed.
[in]	TaskStatus	New task status for the task (TASK_RUN or TASK_STOP).

void Scheduler_Start ( void )

Starts the scheduler in its infinite loop, executing running tasks. This should be placed at the end of the user application's main() function, as it can never return to the calling function.

Variable Documentation

TaskEntry_t Scheduler_TaskList[]

Task entry list, containing the scheduler tasks, task statuses and group IDs. Each entry is of type TaskEntry_t and can be manipulated as desired, although it is preferred that the proper Scheduler functions should be used instead of direct manipulation.

volatile SchedulerDelayCounter_t Scheduler_TickCounter

Contains the current scheduler tick count, for use with the delay functions. If the delay functions are used in the user code, this should be incremented each tick period so that the delays can be calculated.

volatile uint_least8_t Scheduler_TotalTasks

Contains the total number of tasks in the task list, irrespective of if the task's status is set to TASK_RUN or TASK_STOP.

Note:: This value should be treated as read-only, and never altered in user-code.

Data Structures

Defines

Typedefs

Functions

Variables

Detailed Description

Module Source Dependencies

Module Description

Define Documentation

Typedef Documentation

Function Documentation

Variable Documentation