Now for embedded system development people are using operating system to add more features and at the same time reduce the development time of a complex system. This article gives a simple & understandable overview of scheduling technique of embedded system programming for beginners and intermediate programmers. I am considering “C” as the programming language and an application running in a dedicated hardware/device without operating system. The binary output (*.bin file) can be directly running from the device after Power on. In this case, the time scheduling is an important part of system development. We should ensure that the right task should execute at the right time.
What is Embedded System?
An embedded system is some combination of computer hardware and software, either fixed in capability or programmable - it is specifically designed for a particular kind of application device. Or in short we can say, an embedded system is a special-purpose computer system designed to perform one or a few dedicated functions.
All embedded systems need not be a real time system. Real Time systems are those in which timeliness is as important as the correctness of the outputs. Performance estimation and reduction are crucial in real time system. By definition, we can say a real time system is a system that must satisfy explicit (bounded) response time constraints or risk severe consequences, including failure.
Embedded system plays an important part in our daily lives. Most of the people around the globe are highly dependent on different types of gadgets like mobile phones, iPods and many more. The embedded systems used in industrial machines, automobiles, medical equipment, airplanes, and vending machines have to be real time.
I thought of sharing my experience in Embedded systems. This is my first ever article on CodeProject, so I am expecting your valuable feedback and suggestions for betterment.
People are using operating system (RTOS) for complex devices to make it more flexible, add more features and minimize the development time. But it will increase the cost of the device for a small application. So for small application firmware development without operating system is very much popular.
Time scheduling is an important aspect of real-time system. Real time software are executed in response to external events. This event may be periodic, in which case an appropriate scheduling of events and related task is required to guarantee performance. The scheduling strategy also depends on scheduling facilities that the chosen RTOS offers. This article emphasis on the event based technique when there was no operating system running in the device.
Two kinds of scheduling techniques are used in Real-Time system:
- Static Scheduling
- Dynamic Scheduling
This involves analyzing the tasks statically and determining their timing properties. This timing property can be used to create a fixed scheduling table, according to which tasks will be dispatched for execution at run time. Thus the order of execution of the task is fixed, and it is assumed that their execution time is also fixed.
Round Robin scheduling by Time Slicing is one of the ways to achieve static scheduling. Round robin is one of the simplest and most widely used scheduling algorithms; in which a small unit of time known as time slice is defined. Schedulers go around the queue of ready-to-run processes and allocate a time slice to each such process.
Scheduling with Priority
Priority indicates the urgency or importance assigned to a task. There are two approaches of scheduling based on priority based execution – when the processor is idle, the ready task with the highest priority is chosen for execution; once chosen, the task is run to completion.
Preemptive Priority based execution is when the processor is idle, the ready task with highest priority is chosen for execution; at any time, the execution of a task can be preempted if a task of higher priority becomes ready. Thus, at all times, the processor is idle or executing the ready task with the highest priority.
Another kind of scheduling mechanism is known as Dynamic Scheduling – In this case, a real-time program requires a sequence of decisions to be taken during execution of the assignment of resource to transactions. Here each decision must be taken without prior knowledge of the needs of future tasks. Dynamic scheduling is not in the scope of this article, so I am not discussing it in detail here. Perhaps we can discuss it in another article.
Let us take a example of a Master-Slave communication system. Master system is connected to n number of slave systems over serial port (RS 485 network) in multi-drop architecture. Figure 1 shows the typical configuration of this system. Here only one system can talk at a time and others are in listen mode. The Master controls the communication.
In the above case, the
EventManager() are two important functions. For any application, we have number of tasks and a function represents the entry point of a task, like '
CheckDataIntegrity' . When a device receives a complete data packet, it goes for data checking.
RegisterTask() function creates a link-list of function pointers where each node represents a single task. Here I have passed the function pointer
CheckDataIntegrity as an argument.
Main.h should have the following lines:
typedef void (*tEventHandler)(unsigned short *);
typedef struct TaskRecord
struct TaskRecord *pNext;
static tTaskRecord *mpTaskList = NULL;
mpTaskList represents a link-list of function pointers. Considering each node of link list as a entry point of a task, this will execute one by one in
EventManager() function. Below is the definition of
RegisterTask() function which adds the function pointer into the link-list.
void RegisterTask(tEventHandler EventHandlerFunc)
pNewTask = malloc(sizeof(tTaskRecord));
if(pNewTask != NULL)
pNewTask->EventHandler = EventHandlerFunc;
pNewTask->pNext = NULL;
if(mpTaskList == NULL)
mpTaskList = pNewTask;
mpActiveTask = mpTaskList;
while(mpActiveTask->pNext != NULL)
mpActiveTask = mpActiveTask->pNext;
mpActiveTask->pNext = pNewTask;
For this type of application, after initialization there should be an infinite loop for continuous execution. The function
EventManager() at the end of the
main which is nothing but a infinite loop always checks for active tasks or events. If any event occurs, then it passes that event flag as an argument of the function which is already added into the
EventManager() function calls
MainEventHandler() function with
eventID as an argument.
MainEventHandler will check the
eventId and do the necessary action or execute the corresponding code. Here the event should be unique for each event-handler function, i.e. two event-handler functions should not check the same
Definition of EventManager Function
unsigned short AllEvents;
AllEvents = mEventID;
pActiveTask = mpTaskList;
while((AllEvents != 0) && (pActiveTask != NULL))
if(pActiveTask->EventHandler != NULL)
AllEvents = mEventID;
pActiveTask = pActiveTask->pNext;
Event can be generated from interrupt service routine or by checking the status of an input pin in polling mode.
SerialReceiveISR function generates an event after receiving the complete packet. Since the variable
mEventID is modified in the interrupt service routine, it is recommended to disable interrupt while reading.
#pragma interrupt_level 0
void interrupt IService(void)
if(Receivebit == 1)
#pragma inline SerialReceiveISR
static char RxMsgDataCount;
if(Error == 1)
mEventID = mEventID | ATTENTION_REQ_FLG;
else if( RxMsgCount == DataLength)
mEventID = mEventID | DATA_RECEIVE_COMPLETE;
DATA_RECEIVE_COMPLETE flags are two bits of a Global variable
mEventID, which is 16 bits and each bit triggers the corresponding event when set.
#define ATTENTION_REQ_FLAG 0x0008
#define DATA_RECEIVE_COMPLETE 0x0001
When the flag is set, the
EventManager will call all the registered functions with the
eventID as argument.
void MainEventHandler(unsigned short *Event)
if(*Event & DATA_RECEIVE_COMPLETE)
*Event &= ~DATA_RECEIVE_COMPLETE;
Now we can change the variable type to increase the number of flags. If you want to generate multiple number of events, then use a structure rather than a single variable.