A RTOS
G
Anand
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.
