rtos_run() 
Initiates the operation of RTOS. All task control operations are implemented after calling this function.

rtos_terminate() 
Terminates the operation of RTOS. Control returns to the original program without RTOS. In fact, this function is like a return from rtos_run().

rtos_enable() 
Receives the name of a task as an argument. The function enables the task so function rtos_run() can call the task when its time is due.

rtos_disable() 
Receives the name of a task as an argument. The function disables the task so it can no longer be called by rtos_run() unless it is re-enabled by calling rtos_enable().

rtos_ yield() 
When called from within a task, returns control to the dispatcher. All tasks should call this function to release the processor so other tasks can utilize the processor time.

rtos_msg_send() 
Receives a task name and a byte as arguments. The function sends the byte to the specified task, where it is placed in the task’s message queue.

rtos_msg_read() 
Reads the byte located in the task’s message queue.

rtos_msg_ poll() 
Returns true if there is data in the task’s message queue. This function should be called before reading a byte from the task’s message queue.

rtos_signal() 
Receives a semaphore name and increments that semaphore.

rtos_wait() 
Receives a semaphore name and waits for the resource associated with the semaphore to become available. The semaphore count is then decremented so the task can claim the resource.

rtos_await() 
Receives an expression as an argument, and the task waits until the expression evaluates to true.

rtos_overrun() 
Receives a task name as an argument, and the function returns true if that task has overrun its allocated time.

rtos_stats()
Returns the specified statistics about a specified task. The statistics can be the minimum and maximum task run times and the total task run time. The task name and the type of statistics are specified as arguments to the function.

#use rtos(timer=n, minor_cycle=m)

#use rtos(timer=0,minor_cycle=100ms)
// this tells the compiler that the rtos functionality will be needed, that
// timer0 will be used as the timing device, and that the minor cycle for
// all tasks will be 100 miliseconds

#task(rate=n, max=m, queue=p)

#task(rate=20ms, max=100ms)
void my_ticks()
{
...........
...........
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SIMPLE RTOS EXAMPLE
// This is a simple RTOS example. 4 LEDs are connected to lower half of
// PORTB of a PIC18F452 microcontroller. The program consists of 4
// tasks:
// Task task_B0 flashes the LED connected to port RB0 every 250ms.
// Task task_B1 flashes the LED connected to port RB1 every 500ms.
// Task task_B2 flashes the LED connected to port RB2 every second
// Task task_B3 flashes the LED connected to port RB3 every 2 seconds.
// The microcontroller is operated from a 4MHz crystal
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#use delay (clock=4000000)
// Define which timer to use and minor_cycle for RTOS
#use rtos(timer=0, minor_cycle=10ms)
//////////////////////////////////////////////////////////////
// Declare TASK 1 - called every 250ms 
#task(rate=250ms, max=10ms)
void task_B0()
{
output_toggle(PIN_B0); // Toggle RB0
}
////////////////////////////////////////////////////////
// Declare TASK 2 - called every 500ms
#task(rate=500ms, max=10ms)
void task_B1()
{
output_toggle(PIN_B1); // Toggle RB1
}
//////////////////////////////////////////////////////////////////
// Declare TASK 3 - called every second
//
#task(rate=1s, max=10ms)
void task_B2()
{
output_toggle(PIN_B2); // Toggle RB2
}
///////////////////////////////////////////////////////////////////////
// Declare TASK 4 - called every 2 seconds
//
#task(rate=2s, max=10ms)
void task_B3()
{
output_toggle(PIN_B3); // Toggle RB3
}
/////////////////////////////////////////////////////////////
// Start of MAIN program
//
void main()
{
set_tris_b(0); 		// Configure PORTB as outputs
rtos_run(); 		// Start RTOS
}
////////////////////////////////////////////////////////////////////////////

// Start of MAIN program
//
void main()
{
set_tris_b(0); 		// Configure PORTB as outputs
rtos_run(); 		// Start RTOS
}
////////////////////////////////////////////////////////////////////////////

#include <18F452.h>#use delay (clock=4000000)
// Define which timer to use and minor_cycle for RTOS
#use rtos(timer=0, minor_cycle=10ms)

//////////////////////////////////////////////////////////////
// Declare TASK 1 - called every 250ms
#task(rate=250ms, max=10ms)
void task_B0()
{
output_toggle(PIN_B0); // Toggle RB0
}
////////////////////////////////////////////////////////

// Declare TASK 2 – called every 500ms
//
#task(rate=500ms, max=10ms)
void task_B1()
{
output_toggle(PIN_B1); // Toggle RB1
}
//////////////////////////////////////////////////////////////////

// Declare TASK 3 – called every second
//
#task(rate=1s, max=10ms)
void task_B2()
{
output_toggle(PIN_B2); // Toggle RB2
}
///////////////////////////////////////////////////////////////////////

// Declare TASK 4 – called every 2 seconds
//
#task(rate=2s, max=10ms)
void task_B3()
{
output_toggle(PIN_B3); // Toggle RB3
}
/////////////////////////////////////////////////////////////

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
// SIMPLE RTOS EXAMPLE - RANDOM NUMBER GENERATOR
// This is a simple RTOS example. 8 LEDs are connected to PORTB
// of a PIC18F452 microcontroller. Also, a push-button switch is
// connected to port RC0 of PORTC, and an LED is connected to port
// RC7 of the microcontroller. The push-button switch is normally at logic 1.
// The program consists of 3 tasks called "Generator", "Display", and "Live".
// Task "Generator" runs in a loop and increments a counter from 0 to 255.
// This task also checks the state of the push-button switch. When the
// push-button switch is pressed, the task sends the value of the count to the
// "Display" task using messaging passing mechanism. The “Display” task
// receives the value of count and displays it on the PORTB LEDs.
// Task "Live" flashes the LED connected to port RC7 at a rate of 250ms.
// This task is used to indicate that the system is working and is ready for
// the user to press the push-button.
// The microcontroller is operated from a 4MHz crystal
//////////////////////////////////////////////////////////////////////////////////
#include <18F452.h>
#use delay (clock=4000000)
int count;
///////////////////////////////////////////////
// Define which timer to use and minor_cycle for RTOS
#use rtos(timer=0, minor_cycle=1ms)
/////////////////////////////////////////////////////
// Declare TASK "Live" - called every 200ms
// This task flashes the LED on port RC7
#task(rate=200ms, max=1ms)
void Live()
{
output_toggle(PIN_D7);
}
////////////////////////////////////////////////////////
// Declare TASK "Display" - called every 10ms
#task(rate=10ms, max=1ms, queue=1)
void Display()
{
if(rtos_msg_poll() > 0) // Is there a message ?
{
output_b(rtos_msg_read()); // Send to PORTB
}
}
///////////////////////////////////////////////////////////////////
// Declare TASK "Generator" - called every millisecond
#task(rate=1ms, max=1ms)
void Generator()
{
count++; // Increment count
if(input(PIN_D0) == 0) // Switch pressed ?
{
rtos_msg_send(Display,count); // send a message
}
}
//////////////////////////////////////////////////
// Start of MAIN program
//
void main()
{
set_tris_b(0); // Configure PORTB as outputs
set_tris_d(1); // RD0=input, RD7=output
rtos_run(); // Start RTOS
}
////////////////////////////////////////////////////////////

//////////////////////////////////////////////////
// Start of MAIN program
//
void main()
{
set_tris_b(0); // Configure PORTB as outputs
set_tris_d(1); // RD0=input, RD7=output
rtos_run(); // Start RTOS
}
///////////////////////////////////////////////////////////

///////////////////////////////////////////////
// Define which timer to use and minor_cycle for RTOS
#use rtos(timer=0, minor_cycle=1ms)
/////////////////////////////////////////////////////

/////////////////////////////////////////////////////
// Declare TASK "Live" - called every 200ms
// This task flashes the LED on port RC7
#task(rate=200ms, max=1ms)
void Live()
{
output_toggle(PIN_D7);
}
////////////////////////////////////////////////////////

///////////////////////////////////////////////////////////////////
// Declare TASK "Generator" - called every millisecond
#task(rate=1ms, max=1ms)
void Generator()
{
count++; // Increment count
if(input(PIN_D0) == 0) // Switch pressed ?
{
rtos_msg_send(Display,count); // send a message
}
}
//////////////////////////////////////////////////

////////////////////////////////////////////////////////
// Declare TASK "Display" - called every 10ms
#task(rate=10ms, max=1ms, queue=1)
void Display()
{
if(rtos_msg_poll() > 0) // Is there a message ?
{
output_b(rtos_msg_read()); // Send to PORTB
}
}
///////////////////////////////////////////////////////////////////