Prescribed Syllabus:

PRE-REQUISITES: Embedded System Design

COURSE EDUCATIONAL OBJECTIVES:

In this course student will learn about fundamental concepts of real time operating systems, operating
system objects, services and I/O concepts, various interrupts and timers.

COURSE OUTCOMES:

At the end of the course, student will be able to

CO1 Understand the basic set of commands and utilities in Linux/UNIX systems. (Understand – L2)
CO2 Explain the fundamental concepts of real-time operating systems. (Understand – L2)
CO3 Analyze the real-time operating systems objects, services and I/O concept. (Analyze – L4)
CO4 Evaluate various Interrupts and Timers in real-time embedded systems using the concepts of
RTOS. (Apply – L3)

UNIT – I:
Introduction: Introduction to UNIX/LINUX, Overview of Commands, File I/O (open, create, close, lseek,
read, write), Process Control (fork, vfork, exit, wait, waitpid, exec).
UNIT - II:
Real Time Operating Systems: Brief History of OS, Defining RTOS, The Scheduler, Objects, Services,
Characteristics of RTOS, Defining a Task, Tasks States and Scheduling, Task Operations, Structure,
Synchronization, Communication and Concurrency. Defining Semaphores, Operations and Use, Defining
Message Queue, States, Content, Storage, Operations and Use
UNIT - III:
Objects, Services and I/O Pipes, Event Registers, Signals, Other Building Blocks, Component
Configuration, Basic I/O Concepts, I/O Subsystem
UNIT - IV:
Exceptions, Interrupts and Timers: Exceptions, Interrupts, Applications, Processing of Exceptions and
Spurious Interrupts, Real Time Clocks, Programmable Timers, Timer Interrupt Service Routines (ISR),
Soft Timers, Operations.
UNIT V:
RT Linux, MicroC/OS-II, Vx Works, Embedded Linux, Tiny OS, and Basic Concepts of Android
OS.

TEXT BOOKS:
1. Real Time Concepts for Embedded Systems – Qing Li, Elsevier, 2011

REFERENCE BOOKS:
1. Embedded Systems- Architecture, Programming and Design by Rajkamal, 2007, TMH.
2. Advanced UNIX Programming, Richard Stevens
3. Embedded Linux: Hardware, Software and Interfacing – Dr. Craig Hollabaugh
 Unit-5:
RT Linux, MicroC/OS-II, Vx Works, Embedded Linux, Tiny OS, and Basic Concepts of
Android OS.
1 Describe in brief about MicroC/OS-II and list out the features of it.
Micro C/OS- II
Micro C/OS-II is the acronym for MicroController Operating System version 2, which is the
second version of the RTOS developed by Micrium Inc, which became a part of Silicon Labs in
2016.it belongs to μC/OS family of embedded software. It is a Real Time kernel written in ‘C’
language for embedded application development. It supports Multitasking & Priority based pre-
emptive task scheduling. It is available for different family of processors/controllers and
supports processors/controllers ranging from 8bit to 64bit like ARM family of processors, Intel
8085/x86/8051, Freescale 68K series and Altera Nios II are examples for some of the
processors/controllers supported by MicroC/OS-II
The features of the μC/OS kernels include:
Scalable: The μC/OS kernels allow for unlimited tasks and kernel objects. The kernels' memory
footprint can be scaled down to contain only the features required for your application, typically
6–24 KBytes of code space and 1 KByte of data space. This means that a product can have just a
few of μC/OS-II’s services while another product can have the full set of features. This allows
you to reduce the amount of memory (both RAM and ROM) needed by μC/OS-II on a product
per product basis. Scalability is accomplished with the use of conditional compilation.
Portable: Most of μC/OS-II is written in highly portable ANSI C, with target microprocessor
specific code written in assembly language. Assembly language is kept to a minimum to make
μC/OS -II easy to port to other processors.
ROMable: μC/OS-II was designed for embedded applications. This means that if you have the
proper tool chain (i.e. C compiler, assembler and linker/locator), you can embed μC/OS-II as
part of a product.
Efficient: Micrium's kernels also include valuable runtime statistics, making the internals of
your application observable. Identify performance bottlenecks, and optimize power usage, early
in your development cycle.
Reliable : The μC/OS kernels include debugging feature that reduce development time. The
kernels provide extensive range checking, including checks for pointers passed in API calls, task
level services from ISRs, arguments within allowable range, and for valid specified options.
2 Analyze the States of task in MicroC/OS-II kernel

Task States: Under MicroC/OS-II kernel, the tasks may be in one of the following state at a
given point of time.

Dormant: The dormant state corresponds to the state where a task is created but no resources
are allocated to it. This means the task is still present in the program memory and is not moved
to the RAM for execution.
Ready: Corresponds to a state where the task is incepted into memory and is awaiting the CPU
for its turn for execution.
Running: Corresponds to a state where the task is being executed by CPU.
Waiting: Corresponds to a state where a running task is temporarily suspended from execution
and does not have immediate access to resources. The waiting state might be invoked by various
conditions like – the task enters a wait state for an event to occur (E.g. Waiting for user inputs
such as keyboard input) or waiting for getting access to a shared resource
Interrupted: A task enters the Interrupted (or ISR) state when an interrupt is occurred and the
CPU executes the ISR.
3 Explain the task creation & management in Micro C/OS-II kernel
Task Creation & Management
The uC/OS-II supports up to 64 tasks. 8 Tasks are reserved for the uC/OS-II kernel. Each task
should have a unique task priority assigned. No two tasks can have the same priority. In effect
uC/OS-II supports 56 user level tasks. Task priority varies from 0 to 63, with 0 being the highest
priority. Considering the future expansions, uC/OS-II advices developers not to use the priority
values 0, 1, 2, 3, OS_LOWEST_PRIO-3, OS_LOWEST_PRIO-2, OS_LOWEST_PRIO-1and
OS_LOWEST_PRIO. Currently, the uC/OS-II reserves only two task priorities for kernel tasks.
The ID of a task is its priority. A Task Control Block (TCB) is assigned to a task when a task is
created.

4 Describe the Architecture of Vxworks

Architecture of Vxworks
The heart of the Vxworks real time operating system is wind microkernel. The kernel is a part of
the software is acting like a bridge among shell and hardware. The responsibility of the kernel is
to run the programs and providing the secure access to the machine hardware. It maintains a
schedule time table for all process.
5 Summarize the differences of RTOS and GPOS
Main differences of RTOS and GPOS
 Task Scheduling: In GPIOs task scheduling not based on priority. The RTOS task
scheduling always a priority.
 Hardware and economical factors: The efficient to port an RTOS to an embedded
system of limited expectations and functionalities Ex ATM) so inside more logical to use
RTOS and with limited hardware in ATMs. The personal computers use work stations,
service system etc.
 Latency Issue: GPOS is unbounded dispatch latency that means the process and thread
executed without a specific time limit. The RTOS is bounded dispatch latency means all
processes are executed within a specific time limit.
 Pre-emptible Kernal: The RTOS kernel is pre-emptible where as a GPOS kernel is not
pre-emptible. If the kernel is not pre-emptible, then calls/requests from the kernel will
override with all other process and threads.

6 Summarize the Features of VxWorks RTOS

Basic Features: Some important features of VxWorks RTOS are:
1. Multitasking environment using standard POSIX scheduler
2. Ability to run two concurrent Operating systems on a single processing layer
3. Multiple file systems and systems that enable advanced multimedia functionality
4. Synchronization using a full range of IPC options
5. Different context saving mechanisms for the tasks and ISRs
6. Virtual IO devices including pipes and sockets
7. Virtual memory management functions
8. Power management functions to enhance the ability to control power consumption
9. Interconnecting functions that support large number of protocols.
10. Pipe drivers for IPCs
11. Network transparent sockets
12. Networks drivers for shared memory and Ethernet
13. RAM disk drivers for memory-resident files
14. Processor abstraction layer to enable application system design by user when using new
versions of processor architecture.
7 Explain the Memory Management in VxWorks RTOS
The memory management is very important for the operating system that manages the computer
memory. A CPU consists of two types of memory modules such as physical memory and virtual
memory. The virtual memory defined as a RAM memory, and the hard disk is defined as
physical memory. An operating system manages the RAM memory address spaces, and the
allocation of real memory is followed by the virtual memory address.

Memory Management
In VxWorks, all systems and all application tasks share the same address space. This means that
faulty applications could accidentally access system resources and compromise the stability of
the entire system. An optional tool named VxVMI is available that can be used to allow each
task to have its own address space. Default physical page size used is 8KB. Virtual memory
support is available with VxVMI tool. VxWorks does not offer privilege protection. The
privilege level is always 0 (supervisor mode).

8 Describe the Architecture of VxWorks RTOS

VxWorks was initially a development and network environment for VRTX (Versatile Real-
Time Executive). Later Wind River systems developed their own microkernel. So the VxWorks
is of "client-server" architecture from the beginning. The heart of the VxWorks run-time system
is the wind microkernel. This microkernel supports a full range of real-time features including
multi-tasking, scheduling, inter task synchronization/communication and memory management.
All the other functionality is implemented as processes. VxWorks is highly scalable. By
including or excluding various modules, VxWorks can be configured for the use in small
embedded system with tough memory constraints to complex systems where more functions are
 needed. Furthermore, individual modules themselves are scalable. Individual functions may be
removed from the library, or specific kernel synchronization objects may be omitted if they are
not required by the application.

9 List out the states encountered by the task in VxWorks RTOS

Task management:
The VxWorks real-time kernel provides a basic multitasking environment. VxWorks offers both
POSIX and a proprietary scheduling mechanism (wind scheduling). Both preemptive priority
and round-robin scheduling mechanism are available. The difference between POSIX and wind
scheduling is that wind scheduling applies the scheduling algorithm on a system wide basis,
whereas POSIX scheduling algorithms are applied on a process-by-process basis.
IN VxWorks, the states encountered by the task are of 8 different types:
1. Suspended: idle state just after creation or state where execution is inhibited.
2. Ready: waiting for running and CPU access in case scheduled by the scheduler but not
waiting for a message through IPC.
3. Pending: The task is blocked as it waits for a message from the IPC or from a resource; only
 then will the CPU be able to process further.
4. Delayed: sent to sleep for a certain time interval.
5. Delayed + suspended: delayed and then suspended if it is not pre-empted during the delay
period.
6. Pended for an IPC [Inter process Communication] + suspended: Pended and then suspended if
the blocked state does not change.
7. Pended for an IPC + delayed: Pended and then pre-empted after the delayed time interval.
8. Pended for an IPC + suspended + delayed: Pended and suspended after delayed time interval.
Kernel library functions are included in the header files ‘vxWorks.h’ and ‘kernelLib.h’. Task
and system library functions are included in ‘taskLib.h’ and ‘sysLib.h’. User task priorities are
between 101 and 255. Lowest priority means task of highest priority number (255). System tasks
have the priorities from 0 to 99. For tasks, the highest priority is 100 by default.

10 Summarize the functions involved in task management in VxWorks RTOS

The functions involved in task management:
1. Task Spawn function: It is used for creating and activating a task. Prototype is:
Unsigned int taskId=taskSpawn(name,priority,options,stacksize,main,arg0,arg1,arg2,….,arg9)
2. Task suspending and resuming functions:
taskSuspend(taskId): inhibits the execution of task identified by taskId.
taskResume(taskId): resumes the execution of the task identified by taskId.
taskRestart(taskId): first terminates a task and tehn spawn again with its original assigned
arguments.
3. Task deletion and deletion protection functions:
taskDelete(taskId): this permanently inhibits the execution of the task idenitified by taskId
and cancels the allocations of the memory block for the task stack and TCB.
Many times Each task should itself execute the codes for the following:
i. Memory de-allocation
ii. Ensure that the waiting task gets the desired IPC.
iii. Close a file, which was opened before.
iv. Delete child tasks when the parent task executes the exit( ) function.
4. Delaying a task to let a lower priority task get access:
‘int sysClkRateGet ( )’ returns the frequency of the system ticks. Therefore to delay by 0.25
seconds , the function taskDelay(sysClkRateGet ( )/4) is used.
11 Explain the execution of interrupt service routines (ISRs) in VxWorks RTOS
To achieve the fastest possible response to external interrupts, interrupt service routines (ISRs)
in VxWorks run in a special context outside of any thread's context, so that there are no thread
context switches involved. The C function that the user attaches to a interrupt vector is not the
actual ISR. Interrupts cannot directly vector to C functions.
The ISR's address is stored in the interrupt vector table and is called directly from the hardware.
The ISR performs some initial work (e.g. saving registers and setting up stack) and then calls the
C function that was attached by the user. For this reason, we use the term interrupt handler
(instead of ISR) to designate the user installed C handler function. VxWorks uses an ISR design
that is different from a task design. The features of the ISR in VxWorks are:
1. ISRs have the highest priorities and can pre-empt any running task.
2. An ISR inhibits the execution of tasks till return.
3. An ISR does not execute like a task and does not have regular task context.
4. An ISR should not use mutex semaphore.
5. ISR should just write the required data at the memory or buffer.
6. ISR should not use floating-point functions as these take longer time to execute.

12 List out Performance parameters of VxWorks RTOS

Real-time performance: Capable of dealing with the most demanding time constraints,
VxWorks is a high-performance RTOS tuned for both determinism and responsiveness.
Reliability: A high-reliability RTOS, VxWorks provides certification evidence required by
strict security standards. Even for non-safety-critical systems, VxWorks is counted on to run
forever, error free.
Scalability: An indispensable RTOS foundation for very small-scale devices, large-scale
networking systems, and everything in between, VxWorks is the first RTOS to provide full 64-
bit processing to support the ever growing data requirements for embedded real-time systems.
VxWorks is scalable in terms of memory footprint and functionality so that it can be tuned as
per the requirements of the project.
Interrupt latencies: The time elapsed between the execution of the last instruction of the
interrupted thread and the first instruction in the interrupt handler is Interrupt latency. The time
needed to go from the last instruction in the interrupt handler to the next task scheduled to run is
Interrupt dispatch latency. VxWorks 5.3.1 exhibits an interrupt latency of 1.4 to 2.6 micro
seconds and a dispatch latency of 1.6 to 2.4 micro seconds.
 Priority inheritance: VxWorks has a priority inheritance mechanism that exhibits an optimal
performance, which is essential for an RTOS.
Footprint: VxWorks has a completely configurable and tunable small memory footprint for
today’s memory-constrained systems. The user can control how much of the operating system
he needs.

13 Mention the Applications of VxWorks RTOS

VxWorks RTOS is widely used in the market, for a great variety of applications. Its reliability
makes it a popular choice for safety critical applications. VxWorks has been successfully used in
both military and civilian avionics, including the Apache Attack Helicopter, Boeing 787, 747-8
and Airbus A400M. It is also used in on ground avionic systems such as in both civilian and
military Radar stations. Another safety critical application that entrusts VxWorks is BMW’s i-
Drive system. However, VxWorks is also widely used in non-safety-critical applications where
performance is at premium. The Xerox Phaser, a post-script printer is controlled by a VxWorks
powered platform. Link Sys wireless routers use VxWorks for operating switches.
VxWorks has been used in several space applications. In Space crafts, where design challenges
are greatly increased by the need of extremely low power consumption and lack of access to
regular maintenance, VxWorks RTOS can be chosen as the operating system for On Board
Computer [OBC]. For example, ‘Clementine’ launched in 1994 is running VxWorks 5.1 on a
MIPS-based CPU responsible for the Star Tracker and image processing algorithms. The ‘Spirit’
and ‘Opportunity’ Mars Exploration Rovers were installed with VxWorks. VxWorks is also
used as operating system in several industrial robots and distributed control systems.

14 Lit out the life cycle methods of android activity.

Method : Description
onCreate : called when activity is first created.
onStart : called when activity is becoming visible to the user.
onResume : called when activity will start interacting with the user.
onPause : called when activity is not visible to the user.
onStop : called when activity is no longer visible to the user.
onRestart : called after your activity is stopped, prior to start.
onDestroy : called before the activity is destroyed.
15 What is an activity and mention the states of the Activity.
An activity presents a visual user interface (screen), the user can undertake. An Activity is a
single, focused thing that the user can do. It is a crucial component of any Android app. An
Activity typically has a layout associated with it that defines how UI elements appear on a
screen. Android Studio provides Activity templates to help you get started.
Active State:
 When an Activity is in active state, it means it is active and running.
 It is visible to the user and the user is able to interact with it.
 Android Runtime treats the Activity in this state with the highest priority and nevertries to
kill it.
Paused State:
 An activity being in this state means that the user can still see the Activity in the
background such as behind a transparent window or a dialog box i.e it is partiallyvisible.
 The user cannot interact with the Activity until he/she is done with the current view.
 Android Runtime usually does not kill an Activity in this state but may do so in anextreme
case of resource crunch.
Stopped State:
 When a new Activity is started on top of the current one or when a user hits the Homekey,
the activity is brought to Stopped state.
 The activity in this state is invisible, but it is not destroyed.
 Android Runtime may kill such an Activity in case of resource crunch.
Destroyed State:
 When a user hits a Back key or Android Runtime decides to reclaim the memory allocated
to an Activity i.e in the paused or stopped state, It goes into the Destroyedstate.
 The Activity is out of the memory and it is invisible to the user.

16 Mention the Difference between a java program and an android program

Java is one of the most popular object oriented programming languages in the world. Java is
heavily used for software and web development. Recently, Java has become a popular language
for mobile-based applications as well.
Android is a mobile phone based platform developed by Google. Android development is most
of the times java-based. Large portion of Java libraries are available in Android platform, but
 there are many other (non-java) librariesexisting in Android (for user interfaces, etc.) as well.
Java is a programming language, while Android is a mobile phone platform. Android
development is java-based (most of the times), because a large portion of Java libraries is
supported in Android. However, there are key differences. Unlike Java, Android applications do
not have a main function. They have on Crete, on Resume, on Pause and on Destroy functions
that should be overwritten by the developers. Java code compiles to Java byte code, while
Android code compiles in to Davilk opcode.

17 Mention the features of android and also define the service in android.
Main features of android:
 Headset layout Storage
 Connectivity: GSM/EDGE, IDEN, CDMA, Bluetooth, WI-FI, EDGE,3G,NFC, LTE,GPS.
 Messaging: SMS, MMS, C2DM (could to device messaging), GCM (Google could
messaging)
 Multilanguage support Multi-touch
 Video calling Screen capture External storage
 Streaming media support Optimized graphics
A service is a component that runs in the background to perform long-running operations without
needing to interact with the user and it works even if application is destroyed. A service can
essentially take two states :
( 1 ) Started:-
A service is started when an application component, such as an activity, starts it by calling start
Service(). Once started, a service can run in the background indefinitely, even if the component
that started it is destroyed.
( 2 ) Bound:-
A service is bound when an application component binds to it by calling bind Service(). A bound
service offers a client-server interface that allows components to interact with the service, send
requests, get results, and even do so across processes with interprocess communication (IPC).
18 What are the core building blocks of android?
An android component is simply a piece of code that has a well defined life cycle e.g. Activity,
Receiver, Service etc. The core building blocks or fundamental components of android are
 Activities
 Views
 Intents
 Services
 content providers
 Fragments
 AndroidManifest.xml.
Activity:
An activity is a class that represents a single screen. It is like a Frame in AWT.
View:
A view is the UI element such as button, label, text field etc. Anything that you see is a view.
Intent:
Intent is used to invoke components. It is mainly used to:
 Start the service
 Launch an activity
 Display a web page
 Display a list of contacts
 Broadcast a message
 Dial a phone call etc.
For example, you may write the following code to view the webpage.
Intent intent=new Intent(Intent.ACTION_VIEW);
intent.setData(Uri.parse("http://www.javatpoint.com"));
startActivity(intent);
Service:
Service is a background process that can run for a long time.There are two types of services
 local
 remote.
Local service is accessed from within the application whereas
Remote service is accessedremotely from other applications running on the same device.
 Content Provider:
Content Providers are used to share data between the applications.
Fragment:
Fragments are like parts of activity. An activity can display one or more fragments on the screen
at the same time.
AndroidManifest.xml:
It contains informations about activities, content providers, permissions etc. It is like theweb.xml
file in Java EE.

19 Write a short note about the history of Android?

 Android inc. was founded in Palo Alto, California in October 2003 by Andy Rubin, Rich
Miner, Nick sears and Chris w
 The early intention of the company were to develop an advanced operating system for
Digital Cameras.
 When the Company realised that the market for digital camers was not large enough,the
company diverted its focus towards mobile operating system that would rival Symbian
and Microsoft Windows Mobile.
 In July 2005,Google acquired Android Inc. for at least $50million ,who key employees,
including the founders such as Rubin ,Miner and White, stayed at the company after
acquisition.

20
What is TinyOS? How is TinyOS different than Arduino?
TinyOS is an open-source operating system designed for low-power wireless devices, such as
sensor networks, ubiquitous computing, personal area networks, smart buildings and smart
meters.
There are three major differences between TinyOS and Arduino:
1. TinyOS and its APIs are designed for low-power operation; Arduino is not.
2. Arduino focuses on sensing, computation, and digital IO; TinyOS also supports this
abstraction adding excellent support for wireless networking.
3. TinyOS is written in nesC, a C dialect designed for the OS, while Arduino is in C. While
TinyOS programmers can write applications in C, the core OS is in nesC.
21 What is tinyOS? What is the difference between normal OS and tiny OS?
TinyOS is an open source operating system used for wireless devices. This operating system
(OS) is small in size and consumes low memory. The application programs that run on TinyOS
are also small in size as compared to normal OS. Another feature of TinyOS is that it is made for
some specific device. Normal OS is multithreaded and consumes high voltage of computer. But
tinyOS consumes low battery. Normal OS that we use in our computer supports all available
devices and has the large source code. But TinyOS has the small source code and it is written in
nesC language. nesC is a computer language derived from C language. nesC has a separate
compiler.
22 Mention the applications of TinyOS
TinyOS and its applications
TinyOS does not support multithreaded applications because it has low computation power.
Main components of TinyOS are tasks, events, commands, and data. Data is getting from the
outside environment. For example in the smoke detection device, when smoke is detected then
sensor of the device creates event and information about that event is data. Then the command is
made which splits water or any chemical which stops smoke or fire.
Applications of tinyOS
Many applications of TinyOS are there that we see in our daily life. Some of the examples of
devices that use tinyOS are below:-
 Smoke detection device

 Used in military activities

 Temperature control like AC in the room or in car

 Security system in the bank

 Resource monitoring

 Environmental monitoring

 Industrial measurement

 Supports Bluetooth devices

 Used in a microwave oven

 Used in agriculture for detecting fault crop

23 Explain the Memory management in Vx Works
Memory Management in VxWorks:
The latest version of VxWorks (v6) has some improvements comparing to VxWorks 5 and
earlier, considering memory management
Memory protection:
In earlier versions of VxWorks all applications are run in kernel mode, as there is no difference
between user and kernel modes. That gives all application access to the whole address space.
This can lead to problems considering memory protection. To solve this issue in VxWorks 5 and
earlier the solution is to include virtual memory library called VxVMI, allowing applications to
mark data areas private and make it only accessible by the tasks it belongs to. The problem with
this approach is that you will need a memory management unit to use this library. (Silberschatz,
2005)
VxWorks 6 has a different approach but is still supporting the approach above for backward
compatibility. VxWorks 6 are now supporting user-mode and kernels-modes. The kernel runs in
kernel mode and VxWorks real-time processes (RTPs) are running in user-mode. The kernel is
protected from the RTPs and the RTPs are protected from each other. This approach needs, as
well as the approach for VxWorks 5, a memory management unit. (Wind River, 2006a)