|
Defines |
| #define | semaphore_triggered(current, required) ((current) - (required) >= 0) |
| | Has a semaphore been triggered?
|
| #define | TASK_STATE_STARTING 1 |
| | Starting.
|
| #define | TASK_STATE_RUNNING 2 |
| | Running.
|
| #define | TASK_STATE_WAITING_TO_STOP 3 |
| | Waiting for the task to release all of its mutexes before stopping.
|
| #define | TASK_STATE_STOPPING 4 |
| | Stopping.
|
| #define | TASK_STATE_CLEANING_UP 5 |
| | Cleaning up.
|
| #define | TASK_STATE_STOPPED 6 |
| | Stopped.
|
| #define | set_task_state(taskptr, req_state) (taskptr)->status = (req_state) |
| | For internal use only.
Set the state of a task - this macro makes it easier to put other information into task.status
|
| #define | get_task_state(taskptr) ((taskptr)->status) |
| | For internal use only.
Get the state of a task - this macro makes it easier to put other information into task.status
|
| #define | executing_isr() (system.interrupted_task) |
| | For internal use only.
Are we currently executing an ISR?
|
| #define | rtos_started() (current_task) |
| | For internal use only.
Has the RTOS been started?
|
Functions |
| void | task_starter () |
| | For internal use only.
The entry point for all tasks
|
| void | task_stopper () |
| | For internal use only.
The entry point for all tasks that are stopping
|
| int8_t | stop_task (task_t *t, uint8_t wait_for_mutexes) |
| | Stop a task.
|
| task_t * | reserve_task (uint16_t stacklen, uint8_t pri, mutex_t *memory_mutex) |
| | Tasks are kept in a linked list in memory - this function reserves an "empty" task on that list, ready to be subsequently utilised by a call to create_task().
|
| task_t * | create_task (void(*proc)(void *), void(*cleanup)(), void *init_data, uint16_t stacklen, uint8_t pri, mutex_t *memory_mutex) |
| | Create a task, ready to be run.
|
| uint8_t | lock_on (mutex_t *m) |
| | Lock on a mutex.
|
| uint8_t | lock_off (mutex_t *m) |
| | Unlock a mutex.
|
| int16_t | get_semaphore_value (semaphore_t *s) |
| | Get the current value of a semaphore.
|
| uint8_t | wait_for_min_value (semaphore_t *p, int16_t value) |
| | Wait for a semaphore to reach at least a particular value.
|
| uint8_t | wait_for_increment_of (semaphore_t *p, uint16_t amount) |
| | Wait for a semaphore to increment its value by a certain amount.
|
| void | switch_task () |
| | For internal use only.
Perform a task switch
|
| void | increment_semaphore_by (semaphore_t *s, uint16_t amount) |
| | Increment the value of a semaphore by the given amount.
|
| int16_t | get_current_mbox_version (mailbox_t *m) |
| | Get the current version of a mailbox.
|
| void * | read_mbox (mailbox_t *m, int16_t *version) |
| | Read a mailbox.
|
| void * | read_mbox_min_version (mailbox_t *m, int16_t *version) |
| | Wait for a mailbox to reach at least a certain version, and then start reading from it.
|
| mailbox_t * | release_mbox_read () |
| | Function to call when finished reading from a mailbox.
|
| void | initialise_mbox (mailbox_t *m, void *data, const int16_t version) |
| | Initialise a mailbox - this must be called on every mailbox before it is used.
|
| int8_t | mbox_is_empty (mailbox_t *m) |
| | Find out if a mailbox is "empty" (i.e. if there is no-one waiting to read it).
|
| void | write_mbox (mailbox_t *m, void *data, uint8_t wait_for_receivers, uint8_t wait_for_empty_nullify) |
| | Write to a mailbox.
|
| int8_t | write_mbox_now (mailbox_t *m, void *data) |
| | Attempt to write to a mailbox.
|
| void | wait_for_receiver (mailbox_t *m) |
| | Wait for a task to be suspended while trying to read from a mailbox.
|
| interrupt_store_t | disable_interrupts () |
| | Disable interrupts system-wide.
|
| void | restore_interrupts (interrupt_store_t interrupts) |
| | Restore the state of the system-wide interrupts.
|
| void | yield () |
| | Stop executing the current task and try and execute a higher-priority task or another task of the same priority.
|
| void | task_switcher_start (void(*idle)(void *), void *idle_data, uint16_t idle_stacklen, uint16_t system_stacklen) |
| | Start the whole process running.
|
Variables |
| task_t * | first_task = 0 |
| | For internal use only.
Pointer to the first task in our linked list
|
| task_t * | current_task = 0 |
| | The current task.
|
| semaphore_t | task_stopping_semaphore |
| | For internal use only.
A semaphore we use to not return from stop_task() until the task in question has actually stopped
|
| struct system_struct | system |
| | For internal use only.
The system stack, and a flag indicating whether the CPU is currently processing an interrupt
|
For internal use only.
The entry point for all tasks that are stopping
If this task is being stopped by a call to stop_task() with the wait_for_mutexes parameter set, then the task will continue to run as normal until the last mutex is released. When that happens, then this task stopper will start running on the task.
First, interrupts are enabled, then any mailbox being read is released
If the task has a cleanup procedure defined (the cleanup argument to create_task()), it is called
Then, the task state is set to stopped, all mutexes and mailboxes are released, the (internal) task stopping semaphore is signalled, and a task switch is executed.