A RTOS

G Anand

anandg.embedd@gmail.com

RTOS is simple and powerful for standalone embedded systems. Simple kernel handles task switching and task stack for multi-tasking. It can be handled easily by the programmer for self-programing. Boot loaded RTOS kernel can reduce the compiler compiling time.

ARTOS is introduced to simplify the operations when compared to other RTOSs. Interrupt latency is the main problem which is faced by other RTOSs. In this ARTOS a new method is used to avoid interrupt latency. Normally all interrupts access same location in the stack. So interrupt-2 couldn’t access that location until the execution of the interrupt-1. In order to avoid this delay the function to be handled by interrupt-1 will be assigned to another stack variable as a handling function. So program control leaves interrupt 1 and starts to concentrate on the handling function. Inside the handling function user can define their program. Now at the same time, interrupt-2 get serviced and also interrupt 1 will be implemented. In conventional RTOS, only after creation of all tasks, implementation will be performed. ARTOS is designed in-order to perform simultaneous operations. In ARTOS tasks can be created at any point of time. Task creation and implementation can be performed simultaneously. In the process of interrupt handling, to enable and disable Interrupt we need to write coding. But in ARTOS interrupt enable and disable are created as a function. Now it will be easy to access interrupt enable and disable. Thus ARTOS will be user-friendly. ARTOS library functions are explained below.

FEATURES

Ø Task Priority

All the task ruined at least one time in every kernel routine (Total Task switching)

·        LOW:  This priority tasks will be called once after HIGH priority task. It works on the basis of auto task switching. Every time the task can be switched between TMR0 interrupt act. If for loop based delay is used in the task, then it will be difficult to predict the time because of auto switching process. In-order to avoid the task switching in the task in which for loop is used, ARTOS_LOCK () function can be used.

·        HIGH: This priority tasks will be called once before LOW priority task. It works on the basis of auto task switching. Every time the task can be switched between TMR0 interrupt act. If for loop based delay is used in the task, then it will be difficult to predict the time because of auto switching process. In-order to avoid the task switching in the task in which for loop is used, ARTOS_LOCK () function can be used.

·        REALTIME: This priority tasks will be called multiple times after each HIGH and LOW priority tasks. It’s used to debugger task for fetch task status from each calling task. It is a Controlled task. It works on the basis of manual task switching. If once the task resource is allocated to real time priority tasks, then the process will not move to another task. If there is a need to switch the task, then use ARTOS_Idle () function (switching to the next task).

Ø Semaphore

·        All processor’s internal resources are accessed by semaphore.

·        Example: Consider the processor has single serial port. If the same resource is accessed by 2 tasks simultaneously, then data interference will be occurred in serial port.

·        To avoid this CONNECT and DISCONNECT instructions can be used. If one task is already connected to the serial port, other tasks should wait to establish connection to that resource.

Ø IPC (Inter Process Communication)

·        Pointer based IPC. Only the Variable address will be transferred from one process to another process. Thus any data type  and large data can be accessed from another task

·        Perfect address handling is done with the help of global and heap variables.

·        Semaphore based data communication.

Ø Interrupt Handling

·        Easy to access interrupt functions

·        All interrupts are enabled and disabled by inbuilt functions and interrupt event handles header functions.

·        Software nested interrupt sequence

·        Interrupt Priority

§  LOW: Handle has individual stack. It processes newly arrived LOW and HIGH priority interrupts. If HIGH or LOW interrupt comes into play while one low priority interrupt is in process, then current interrupt context has been saved and jump to next interrupt. All the interrupts are processes in the manner last in first out.

§  HIGH: Handle has individual stack. It processes newly arrived HIGH priority interrupt. If one interrupt is processing at the same time another HIGH interrupts comes into play, then the Current interrupt context has been saved and jump to next interrupt. All the interrupts are processed in the manner last in first out.

§  REALTIME: Handle has no individual stack. All the interrupts are processed in the manner last in first out.

·        If user enabled the TMR interrupt, it generates interrupt event handling function and call this function every interrupt occur.

·        TMR0 interrupt is reserved for kernel routine. This interrupt event can be used for fixed kernel time. If the time of this interrupt kernel is changed, only the time will be changed and the other system operations will not be affected.

Ø UART function

·        Interrupt based TX an RX

·        Buffered receiver which doesn’t listen every time while receiving

·        Semaphore based UART functions like sending and receiving operations using byte and string.

Ø System Timer

·        Inbuilt HR: MIN: SEC: MSEC: USEC task for perfect timer operation.

·        Get system time sample for timeout operation.

·        Use Kernel Timer (TMR0) , so don’t need special timer

·        LOW priority task only.

Ø Auto prediction of the function stack top

Ø Main routine is like individual task. This task is handled by ARTOS_INIT function

Ø Inbuilt library

·        GSM

·        Audio reader

·        LCD

·        ALARM

·        Multi data type EEPROM ( int, char, string..)

·        Seven Segment

·        DS1307 (Timer chip)

·        Bounce Button

·        Soft button

·        Universal IR decoder

FUNCTIONS

Ø int8 ARTOS_Init(uint16 Main_ThreadID,int8 *Main_Stack,uint16 Main_Stack_Depth,uint8 Main_Task_Priority);

This function should be called before calling other functions (i.e at initial stage).  In our ARTOS, creation and implementation of tasks are performed simultaneously. For this simultaneous operation init function should be declared at first. Consider the main function consists of 2 tasks.

Main()

{

int8 ARTOS_Init(uint16 Main_ThreadID,int8 *Main_Stack,uint16 Main_Stack_Depth,uint8 Main_Task_Priority);

Task 1

- - - - - - - - - - - -

- - - - - - - - - - - -

Task 2

}

Used to back up the main task context

First task 1 will be created and implemented initially. Task 1 will be interrupted after particular time delay and the program control switch into task 2 creation and implementation. This will be interrupted after particular time delay and the program control has switched to task 1. Thus the simultaneous operation can be achieved.

Default delay time is 500 micro seconds. We can change this delay time according to our need. In other versions of RTOS first we should create task in the main function.  Only after creation of all tasks OS starts to implement them. If the OS starts to implement the tasks, then it will never return to the main function.

To declare init function we need to assign thread ID(uint16 Main_ThreadID), stack name(int8 *Main_Stack), stack size(uint16 Main_Stack_Depth) and priority(uint8 Main_Task_Priority).

Thread ID

It should be 16 bit number. Avoid assigning FF as main thread ID because some inbuilt function has used FF as their thread ID.

Stack name and size:

These arguments are used to define stack to store temporal variables of the main function. This stack does not include particular task variable. If we implement the tasks only after creation then there is no need to keep track of main function. We are performing creation and implementation of tasks simultaneously. So we need to keep track of main function. For this purpose, a stack should be defined to store temporal variables of the main function. This stack does not include particular task variable.

Priority:

There are 3 priorities in our system design. They are low priority, high priority and real_time priority. In these, real_time priority has most significance than other priorities. Second most significant priority is High priority. Least significant priority is Low priority.

If 2 tasks (task 1- high priority, task 2- Low priority) are waiting for the input from the same source, then the task will get the input from the source according to their priority. Normally after particular delay, program control will be switched into another task. If we assign the priority as realtime_priority then the program control will not be switched into another task after particular delay. Only after completing the task program control will be switched into another task.

Ø void ARTOS_ASM_delay(uint8 Nnop);

This function is used to provide assembly delay. It indicates number of no-operation to be performed.

Ø int8 ARTOS_ChangePriority(uint8 Thread_Priority);

This function is used to change the priority of the task (thread) at any step.

Ø int8 ARTOS_Create( uint16 Thread_ID,__Thread Thread_ADDR ,int8 *Stack,uint16 Stack_Depth,int8 *IPC, int8 Thread_Priority );

Create function is used to generate new task. To generate new task thread id, thread address, stack name, stack size, pointer value and thread priority should be given as input arguments.

Uint16 Thread_ID: Should be 16 bit number

Thread_ADDR: Address allocated for the task

Ø int8 *Stack(name), uint16 Stack_Depth(size):

Stack is used to store the variables associated with the task. We need to assign name and size of the stack.

Ø int8 *IPC(pointer value):

Pointer value is used to address the location of the variables used. The change made in the variable will be updated in the address location(denoted by the pointer) directly.

Ø int8 ARTOS_Start(  uint16 Thread_ID );

This function is used to start the implementation of the task which is created and stored in the buffer. After creating each task we need to declare start operation to implement that task. We can start any task from any step using the ID of the task.

Ø int8 ARTOS_Stop(  uint16 Thread_ID );

This function is used to stop the implementation of the task. Normally after particular delay, program control will be switched into another task. Once the program control get the stop command of particular task, then the program control should not get into task until the task is started by using start function We can stop any task from any step using the ID of the task.

Ø int8 ARTOS_Delete(  uint16 Thread_ID );

This function is used to delete the particular task using task ID(thread ID). This function clear the memory associated with the task.

Ø void ARTOS_Return();

This function is used to return the output of a function.

Return value = 0 indicates the output of a function has returned successfully

Return value = negative number indicates the return of output is unsuccessful

Ø void ARTOS_Idle();

This function is used to idle the function for one cycle.

Main()

{

int8 ARTOS_Init(uint16 Main_ThreadID,int8 *Main_Stack,uint16 Main_Stack_Depth,uint8 Main_Task_Priority);

Task 1

- - - - - - - - - - - -

- - - - - - - - - - - -

Task 2

- - - - - - - - - - - -

Idle function

- - - - - - - - - - - -

Task 3

- - - - - - - - - - - -

- - - - - - - - - - - -

Task 4

- - - - - - - - - - - -

- - - - - - - - - - - -

}

First task 1 will implemented. It will get interrupted after particular delay time. And the program control will be switched into task 2. In task 2 we have idle function. So task 2 will not be performed. Program control will be switched into task 3. task 3 will be performed and it will get interrupted after particular delay time. Then the program control will be switched into task 4. It will get interrupted after particular delay time. Then the program control will be switched into task 1. Then the

Ø void ARTOS_Delay(uint16 delay_ms);

This function is used provide delay. We should pass delay time as argument of this function.

Ø void ARTOS_Lock();

Normally after particular delay, program control will be switched into another task. Lock function is used to avoid this switching. So the program control moved to next task only after completing the task which has lock function. This will be helpful to avoid switching in-case of low and high priority tasks.

Ø void ARTOS_UnLock();

This function is used to unlock the task which was locked.

 Download paper