ESD Manual Students

Lab Manual-Embedded System Design, B.E.
-VII, Electronics
LAB MANUAL
EMBEDDED SYSTEM DESIGN

SEM-VII
B.E. (ELECTRONICS)
2016-2017
SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE
Page 1
Lab Manual-Embedded System Design, B.E.-VII, Electronics
LIST OF EXPERIMENTS
1. Arithmetic and logic unit using mixed C/C++ and assembly language
2.
3.
4.
5.
6.
programming.
To study the ADC functionality using LPC2148.
To simulate UART functionality of LPC2148 on hyperterminal.
Design traffic light controller system with LPC2148 using Proteus and
Keil-4.
Implementation of RMS and EDF task scheduling algorithm.
To plot Gantt chart for RMS and EDF scheduling using Torsche toolbox in
MATLAB.
7. Mobile application using J2ME to display text message and to display
images.
8. Write a program to implement multithreading in LINUX.
9. Implement RTOS function for Semaphore in LINUX.
10.To demonstrate RTOS application of tank monitoring system using ucos-2.
11.Case study seminar.
Page 2
Experiment-1
Title:- Arithmetic and Logic Unit
Aim:- Using mixed C/C++ and assembly language programming, implement Arithmetic and
Logic Unit to perform following operations: +, -, *, /, power, log, square root, factorial, nth root,
AND, OR ,XOR, NOR, left shift, right shift.
Learning Objective:-Embedding the assembly language code in high level language is the
powerful feature of C programming for Embedded systems. This is the way to optimize
speed/memory requirements from embedded system point of view.
Theory:1. With the help of suitable examples, describe following C-program elements:
I.
Header file
II.
Preprocessor directives
III.
MACROS
IV. Modifiers
V. Functions
2. What is a Device Driver? Discuss its role in layered embedded system.
3. What is Interrupt latency in embedded system? Suggest methods to reduce latency.
4. Explain the following data types used in C programming:
I.
Array
II.
Structure
III.
Link list
IV. Queues
Algorithm:1.
2.
3.
4.
5.
Preprocessor directives
Variable declaration
Input statements
Switch-case
Result
Conclusion:-
ALU program:#include<stdio.h>
Page 3

#include<conio.h>
#include<math.h>
void main()
{
int a,b, choice, result;
printf(\n1. ADD \n2. SUB \n3. MUL \n4. DIV \n5. AND \n6. XOR \n7. OR \n8.EXIT);
printf(\nEnter your choice);
scanf(%d,&choice);
printf(\nEnter two numbers);
scanf(%d %d,&a,&b);
switch(choice)
{
Case 1: asm{
mov ax, a;
mov bx, b;
add ax, bx;
mov result, ax;
}
printf(\n Addition=%d, result);
break;
Case 2: asm{
mov ax, a;
mov bx, b;
sub ax, bx;
mov result, ax;
}
printf(\n Subtraction=%d, result);
break;
Case 3: asm{
mov ax, a;
mov bx, b;
mul bx;
mov result, ax;
}
printf(\n Multiplication=%d, result);
break;
Case 4: asm{
mov ax, a;
mov bx, b;
ALU program:div bx;
Page 4

mov result, ax;
}
printf(\n Division=%d, result);
break;
Case 5: asm{
mov ax, a;
mov bx, b;
AND ax, bx;
mov result, ax;
}
printf(\n AND=%d, result);
break;
Case 6: asm{
mov ax, a;
mov bx, b;
xor ax, bx;
mov result, ax;
}
printf(\n XOR=%d, result);
break;
Case 7: asm{
mov ax, a;
mov bx, b;
or ax, bx;
mov result, ax;
}
printf(\n OR=%d, result);
break;
case 8:
break;
default: printf(\nEnter proper choice);
}
getch():
}
OUTPUT..?????
Page 5
Experiment-2
Title:- ADC Implementation
Aim:- Write a program in Embedded C to study the ADC functionality of LPC2148.
Learning Objective:-To study inbuilt ADC functionality, data register AD0DR3 and get digital
output of corresponding analog input voltages of LPC2148.
Theory:1. Draw and explain basic architecture of ARM7 TDMI.
2. List and explain various program modeling techniques.
3. Draw and explain basic architecture of ARM CORTEX M3.
Algorithm:1.
2.
3.
4.
5.
6.
7.
Initialize the PLL system to generate 30 MHZ clock.

Select the fast version of I/O ports.
Initialize UART1, to display ADC output on hyper-terminal.
Enable AD0.3 for analog input.
Write control word of ADC to get 10-bit output AIN0 at 3MHz, to start A/D conversion.
Extract the A/D result from ADC data register.
Display output to Terminal program using UART1.
Procedure:1.
2.
3.
4.
5.
6.
7.
Built new project in the keil 4 compiler.

Write a program in embedded C and compile it to get hex file.
Run the program for ADC peripherals and observe bits of data register AD0DR3.
Keep Vref as 1.5V and input analog values <=1.5V
Observe contains of data register and result. Justify.
Repeat above steps 4 and 5 for other values of Vref.
What is the maximum value possible for Vref.
Conclusion:-
Page 6
Page 7

ADC program://------------------------------------------------------------------------------------------------//
// Program
: Example Analog to Digital converter
// Description : Display Analog to Digital convert value on terminal program(used UART0

communication)
// Frequency : Crystal 12 MHz at PLL 5x(CCLK = 60 MHz),PCLK = 30 MHz
// Filename
: adc.c
// C compiler : Keil CARM Compiler

//------------------------------------------------------------------------------------------------//
#include "lpc214x.h" // Header file for Phillips LPC2148 controller
#include "stdio.h"
// Library for sprintf function
#include "uart.h"
// Library for UART
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for Initial system clock --------------------------------//
//------------------------------------------------------------------------------------------------//
void init()
{
PLL0CFG=0x24;
// MSEL = 4,PSEL = 2
PLL0FEED=0xAA;
// Feed process
PLL0FEED=0x55;
PLL0CON=0x1;
PLL0FEED=0xAA; // Feed process
PLL0FEED=0x55;
Page 8

ADC program:while(!(PLL0STAT & 0x400)) ; // Wait until PLL Locked
PLL0CON=0x3;
// Connect the PLL as the clock source
PLL0FEED=0xAA;
// Feed process
PLL0FEED=0x55;
MAMCR=0x2;
// Enabling MAM and setting number of clocks used for Flash
memory fetch (4 cclks in this case)
MAMTIM=0x4;
VPBDIV=0x02;
// PCLK at 30 MHz
}
//------------------------------------------------------------------------------------------------//
//---------------------------------- Function delay ----------------------------------------------//
//------------------------------------------------------------------------------------------------//
void delay_ms(long ms) // delay 1 ms per count @ CCLK 60 MHz
{
long i,j;
for (i = 0; i < ms; i++ )
for (j = 0; j < 6659; j++ );
}
//------------------------------------------------------------------------------------------------//
//---------------------------------- Main Program ------------------------------------------------//
Page 9

ADC program://------------------------------------------------------------------------------------------------//
void main()
{
int val=0;
char s[30]; // Buffer for keep string from integer convert
init();
// Initialize the system
SCS = 0x03; // select the "fast" version of the I/O ports

uart0_init(9600); // Initial UART0
PINSEL1 |= 0x10000000; // Enable AD0.3 for used
AD0CR = 0x00210608; // Setup A/D: 10-bit AIN0 @ 3MHz
//AD0CR = 0x00270607;
while (1)
{
AD0CR |= 0x01000000; // Start A/D Conversion
while ((AD0DR3 & 0x80000000) == 0); // Wait for the conversion to complete
val = ((AD0DR3 >> 6) & 0x03FF);
sprintf(s,"Analog(AD0.3): %d
// Extract the A/D result
\r",val); // Convert string to display analog value
uart0_puts(s); // Display to Terminal program

delay_ms(200); // Delay for display
}
}
Page 10

Result (ADC):Sr No.
Vref
1.5
3.3
Analog I/P
(AD03)
1.1
1.2
1.3
1.1
2.2
3.3
Data Register Contents

(AD0DR3)
Result
Conclusion:-
Page 11
Experiment-3
Title:- UART Implementation
Aim:- Write a program in Embedded C to study the UART functionality of LPC2148.
Learning Objective:-To transmit data from UART0/UART1 module in LPC2148 by using serial
port interface unit and observe the operation in hyper terminal window
Theory:1. Draw and explain basic architecture of ARM CORTEX M4.
2. Compare and discuss difference between the two cortex architectures.
3. How will you interface I2C, LCD, RS232 and Alarm circuit with any ARM based
microcontroller?
4. Give detail comparison between RS232 and RS485.
Algorithm:1.
2.
3.
4.
5.
Initialize the system.

Select the fast version of the I/O ports.
Initialize UART0 @ 9600 bps, 8-bit data, 1 stop bit, no parity bit.
Initialize UART1 @ 9600 bps, 8-bit data, 1 stop bit, no parity bit.
While(1)
Send string to UART0
Send string to UART1
6. Stop
Procedure:1. Build new project in the name uart_0_1.
2. Write the program. Compile to uart_0_1.hex and download to microcontroller with flash
magic.
3. Open the terminal program such as hyper terminal or RS-232 terminal to test the
operation. Set baud rate to 9600 bps.
4. Connect serial port cable from computer RS-232 port to UART CH.0 connector on JX2148 board. If another serial port is available, connect the serial cable to UART CH-1
connector.
5. Run the program. Watch the result on the terminal program operation.
Conclusion:UART Program:-
Page 12

//------------------------------------------------------------------------------------------------//
// Program
: Library for serial communication (UART)
// Description : Library for about serial communication UART0 and UART1 of LPC2148
// Frequency : Crystal 12 MHz at PLL 5x(CCLK = 60 MHz),PCLK = 30 MHz
// Filename
: uart.h

//------------------------------------------------------------------------------------------------//
#define _PCLK 30000000 // Define PCLK for configuration baudrate

#define uart1_setbaud(x) uart1_init(x) // Define function name uart1_setbaud equal uart1_init
#define uart0_setbaud(x) uart0_init(x) // Define function name uart0_setbaud equal uart0_init
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for Initial UART1 ----------------------------------------//
//------------------------------------------------------------------------------------------------//
void uart1_init(unsigned int _baudrate)
{
unsigned short u1dl;
u1dl = _PCLK/(16*_baudrate);
// Calculate for U1DL value
PINSEL0 |= 0x00050000; // Enable rx,tx

U1LCR = 0x00000083;
// 8 bit data,1 stop bit,no parity bit
U1DLL = u1dl & 0xFF; // U1DL for low byte

U1DLM = (u1dl>>8);
U1LCR = 0x00000003;
// U1DL for high byte

// DLAB =0
UART Program:SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE
Page 13

}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send character 1 time via UART1-----------------------//
//------------------------------------------------------------------------------------------------//
void uart1_putc(char c)
{
while(!(U1LSR & 0x20)); // Wait until UART1 ready to send character
U1THR = c; // Send character
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send string via UART1---------------------------------//
//------------------------------------------------------------------------------------------------//
void uart1_puts(char *p)
{
while(*p) // Point to character
{
uart1_putc(*p++); // Send character then point to next character
}
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for Initial UART0 ----------------------------------------//
//------------------------------------------------------------------------------------------------//
void uart0_init(unsigned int _baudrate)
Page 14

{
unsigned short u0dl;
u0dl = _PCLK/(16*_baudrate); // Calculate for U0DL value
PINSEL0 |= 0x00000005; // Enable rx,tx
U0LCR = 0x00000083;
// 8 bit data,1 stop bit,no parity bit
U0DLL = u0dl & 0xFF; // U0DL for low byte

U0DLM = (u0dl>>8);
// U0DL for high byte
U0LCR = 0x00000003;
// DLAB =0
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send character 1 time via UART0-----------------------//
//------------------------------------------------------------------------------------------------//
void uart0_putc(char c)
{
while(!(U0LSR & 0x20)); // Wait until UART0 ready to send character
U0THR = c; // Send character
}
//------------------------------------------------------------------------------------------------//
//---------------------------- Function for send string via UART1---------------------------------//
//------------------------------------------------------------------------------------------------//
void uart0_puts(char *p)
{
while(*p) // Point to character
Page 15

{
uart0_putc(*p++); // Send character then point to next
character
}
}
UART_0_1.c
//------------------------------------------------------------------------------------------------//
// Program
: UART example
// Description : Example for test module UART0 and UART1

// Frequency : Crytal 12 MHz at PLL 5x(CCLK = 60 MHz),PCLK = 30 MHz
// Filename
: uart_0_1.c

//------------------------------------------------------------------------------------------------//
#include "lpc214x.h" // Header file for Phillips LPC2148 controller
#include "uart.h"
// Library for use module UART0,UART1(from jx2148_include floder)
#include "stdio.h"
// Library for use printf function(For UART1)
//------------------------------------------------------------------------------------------------//
//---------------------------------- Initial system clock ----------------------------------------//
//------------------------------------------------------------------------------------------------//
void init()
{
PLL0CFG=0x24;
// MSEL = 4,PSEL = 2
PLL0FEED=0xAA;
// Feed process
PLL0FEED=0x55;
UART_0_1.c program:SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE
Page 16

PLL0CON=0x1;
PLL0FEED=0xAA; // Feed process
PLL0FEED=0x55;
while(!(PLL0STAT & 0x400)) ; // Wait until PLL Locked
PLL0CON=0x3;
// Connect the PLL as the clock source
PLL0FEED=0xAA;
// Feed process
PLL0FEED=0x55;
MAMCR=0x2;
// Enabling MAM and setting number of clocks used for Flash
memory fetch (4 cclks in this case)
MAMTIM=0x4;
VPBDIV=0x02;
// PCLK at 30 MHz
}
//------------------------------------------------------------------------------------------------//
//---------------------------------- Main Program ------------------------------------------------//
//------------------------------------------------------------------------------------------------//
void main()
{
init();
// Initialize the system
SCS = 0x03; // select the "fast" version of the I/O ports

uart0_init(9600);
// Initial UART0 @ 9600 bps,8 bit data ,1 stop bit ,no parity bit
uart1_init(9600);
// Initial UART1 @ 9600 bps,8 bit data ,1 stop bit ,no parity bit
UART_0_1.c program:while (1)

Page 17

{
uart0_puts("Test UART0\r\n");
printf("Test UART1\r\n");
// Send string to UART0
// Send string to UART1
}
}
Experiment-4
Title:- Design and test circuit for demonstration of traffic lights using ARM processor.
Page 18

Aim:- Design system based on LPC2138 using PROTEUS VSM for demonstration of traffic
light.
Learning Objective:- Designing system based on ARM processor. Write program for the
demonstration of the traffic light system.
Theory:- Traffic lights are interfaced to ARM controller. According to sequence of traffic lights
GREEN, RED, ORANGE lights are made ON and OFF for specified time duration.
Algorithm:1
2
3
4
5
6
7
8
9
10
11
12
13
14
Set port direction

Send data to port according to sequence 1
Give delay
Clear port
Give delay
Clear port
Give delay
Clear port
Give delay
Clear port
To repeat sequence go to step 2.
Start
Set port direction
Send
data to port
0 for
SHAH AND ANCHOR KUTCHHI
ENGINEERING
COLLEGE
sequence
Send
data
port
forsequence
sequence
Send
datatoto
portport
00for
4
Clear
0
Give delay
Page 19
Give delay
Clear port
Send data to port 0 for sequence 2
Give delay
Clear port 0
Traffic light system program:#include<lpc21XX.h>

void delay()
{
int i,j;
Page 20

for(i=0;i<1000;i++)
{
for(j=0;j<1000 ;j++);
}
}
void main(void)
{
IODIR0=0X0000FFFF;
while(1)
{
IOSET0=0X00000914;
delay();
IOCLR0=0X0000FFFF;
IOSET0=0X00000A21;
delay();
IOCLR0=0X0000FFFF;
IOSET0=0X00001409;
delay();
IOCLR0=0X0000FFFF;
IOSET0=0X0000210A;
delay();
IOCLR0=0X0000FFFF;
}
}
Conclusion:-
Experiment-5
Title:- Implementation of RMS and EDF scheduling algorithms.
Aim:- Write a program in C/C++ to implement task scheduling algorithms:
Page 21

1) Rate monotonic scheduling
2) Earliest deadline first scheduling.
Learning Objective:-To learn the application of schedulability theorem from CPU utilization
and use softwares Cheddar as well as MATLAB Torche toolbox to compare RMS and EDF
scheduling algorithms.
Theory:1. What is preemptive scheduling? Explain context switching and CPU utilization.
2. State total utilization theorem and utilization bound theorem and explain their application
with the example you have used for the program.
3. If the given set of tasks is not schedulable, what will you do to make the system
schedulable?
4. What is priority inversion? Discuss the various ways to overcome the same.
Algorithm:1.
2.
3.
4.
5.
6.
7.
Input task id for 4/5 different periodic tasks.

Input time period and execution time along with deadline for each task.
Set the priorities for RMS scheduling and apply total utilization theorem.
Apply utilization bound theorem and write a comment on the (RMS) schedulability.
Set the priorities for EDF scheduling and apply total utilization theorem.
Apply utilization bound theorem and write a comment on the schedulability.
Input your task data and see the output on Cheddar as well as MATLAB Torche toolbox
Conclusion:
Experiment-6
Title: - TORSCHE scheduling toolbox in MATLAB
Aim:- To plot Gantt chart for Rate monotonic & Earliest Deadline First Scheduling using
TORSCHE Toolbox in Matlab.
Page 22

Learning Objective: - TORSCHE Scheduling Toolbox for Matlab for off-line and on-line
scheduling. The toolbox includes scheduling algorithms that are used for various applications.
Software Requirements: - TORSCHE Scheduling Toolbox for Matlab (0.4.0) currently supports
MATLAB 6.5 (R13) and higher versions. We can use the toolbox on different platforms like MSWindows or Linux on PC (32bit) compatible, some algorithms must be compiled by a C/C++
compiler. We can use Microsoft Visual C/C++ 7.0 and higher under Windows or gcc under
Linux.
Theory: - TORSCHE Scheduling Toolbox for Matlab is a freely available toolbox of the
scheduling algorithms. The toolbox offers a collection of data structures that allow the user to
formalize various off-line and on-line scheduling problems. Algorithms are simply implemented
as Matlab functions with fixed structure allowing users to implement new algorithms. A more
complex problem can be formulated as an Integer Linear Programming problem. The toolbox is
intended mainly as a research tool to handle control and scheduling co-design problems.
Therefore, it provides an interface to a real-time Matlab/Simulink based simulator TrueTime and
a code generator allowing generating parallel code for FPGA.
TORSCHE (Time Optimization of Resources, SCHEduling) is a MATLAB-based toolbox
including scheduling algorithms that are used for various applications such as high level
synthesis of parallel algorithms or response time analysis of applications running under fixedpriority operating system. Using the toolbox, one can obtain an optimal code of computing
intensive control applications running on specific hardware architectures. The tool can also be
used to investigate application performance prior to its implementation.
The toolbox offers a collection of Matlab routines that allow the user to formalize the
scheduling problem, while considering appropriate configuration of resources (e.g. Field
Programmable Gate Arrays (FPGA) based architecture [1] or micro controllers with real-time
operating system [2]), task parameters (e.g. deadlines, release dates, preemption) and
optimization criterion (e.g. make span minimization, maximum lateness minimization, the task
completion prior its deadline).
TORSCHE is written in Matlab object oriented programming language and it is used in
Matlab environment as a toolbox. Main objects are Task, TaskSet and Problem. Object Task is a
data structure including all parameters of the task as processing time, release date, deadline etc.
These objects can be grouped into a set of tasks with other related information as precedence
constraints into a TaskSet object. Object Problem is a small structure. These objects are used as a
basis that provide general functionality and make the toolbox easily extensible by other
scheduling algorithms.
In scheduling problems, the task is given by the following parameters:
Page 23

Processing time, pj , is time necessary for task execution (also called computation time).
Release date, rj , is the moment at which a task becomes ready for execution (also called
arrival time, ready time, request time).
Deadline, dj , specifies a time limit by which the task has to be completed, otherwise the
scheduling is assumed to fail.
Due date, dj , specifies a time limit by which the task should be completed, otherwise
the criterion function is charged by penalty.
Weight expresses the priority of the task with respect to other tasks (also called priority).
Processor specifies dedicated processors at which the task must be execute.
Resulting schedule is represented by the following parameters:
Start time, sj , is the time when the execution of the task is started.
Completion time, cj , is the time when the execution of the task is finished.
Lateness, Lj = cj dj .
Tardiness, Dj = max{cj dj , 0}. The task is represented by the object data structure with the
name Task in Matlab.
This object is created by the command with the following syntax rule:
t1 = task([Name,]ProcTime[,ReleaseTime ... [,Deadline[,DueDate[,Weight[,Processor]]]]])
The object Problem is used for classification of deterministic scheduling problems.
prob = problem(P|prec|Cmax)
The first part describes the processor environment, the second part describes the task
characteristics of the scheduling problem as the precedence constrains, or the release time. The
last part denotes an optimality criterion.
Steps to solve Scheduling Problems
Page 24

Solving procedure of scheduling problem can be divided into four basic steps:
1. Define task
2. Define a set of tasks.
3. Define the scheduling problem.
4. Run the scheduling algorithm.
Conclusion:-
TORSCHE PROGRAM
1). EDF
t1=task('t1',3,0,12);
t2=task('t2',5,2,14);
t3=task('t3',4,3,16);
Page 25

T=taskset([t1 t2 t3]);
P=problem('1|pmtn,rj|Lmax');
Ts=horn(T,P);
plot(Ts)
2). RMS
t1=ptask('t1',3,7);
t2=ptask('t2',3,12);
t3=ptask('t3',5,20);
ts= [t1 t2 t3];
setprio(ts, 'rm')
[r,s] = resptime(ts)
s = fps(ts)
plot(s, 'proc',1);
Experiment-7
Title:-
Mobile application using J2ME
Aim:- Design the following program using J2ME

a) Display text message
b) Immutable image and mutable image
Learning Objective:J2ME is compatible with all java enabled devices. A java
enabled devices is any computer that runs the JVM (java virtual machine). J2ME
services many different kinds of small computing devices.
Page 26

Theory:J2ME ( Java-2 Micro Edition) is a platform designed for embedded
systems. J2ME addresses the need to create mobile and embedded components
that makes those systems accessible from other than the desktop.
A user interface for a J2ME application is similar to yet different from a user
interface that you find on a desktop application. J2ME application is accessed and
manipulated by both server side components such as web services and client side
application.
a) Display text message:
addcommand(): The command object associated with textbox
message.
startApp() & destroyApp(): It associates the textbox object with display
object & Quit command. pauseApp() & destroyApp() is usually empty
because no action is to be taken when Helloworld MIDLET is paused
and destroyed.
commandAction(): It contains statements that evaluate events that
occur while Helloworld MIDLET is running.
b) Immutable & mutable image:
An immutable image is loaded from a file or other resources and cannot be
modified once the image is displayed. Icons associated with MIDLET are
immutable images. A mutable image is drawn on the screen using methods
available in Graphic class. Once drawn MIDLET can redraw any portion of the
image. An immutable image is drawn on a screen & mutable image is drawn
on a canvas.
1) Displayable class has two derived classes: The screen class and
canvas class. Immutable images are displayed using an instance of
image item class which inherits from Item class.
2) The first step in displaying an immutable image is to create an

instance of image class by calling the createImage() method. Next
constructor of an Image Item class requires four parameters. First is
string that becomes a label of image. Second parameter is referred to
instance of Image class created in step-1. The third parameter is
layout directive. The fourth parameter is string to an alternate text
that is displayed in place of image by the device. Similarly is done in
mutable image.
Page 27

Algorithm:1
2
3
4
5
Import the files

Take the parameters and declared as private
Use parameterized constructor
Apply try-catch method
Display the message or image
Conclusion:Hence we studied J2ME application which is accessed & manipulated by both

client side and server side. Also we have implemented the programs using J2ME
application where display text programs used MIDLET functions. The immutable
image & mutable image program uses the graphic class methods.
J2ME program:a) Display text message:

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class Helloworld extends MIDLET implements CommandListener
{
private Display display;
private TestBox textBox;
Page 28

private Command quitCommand;
public void startApp()
{
display = Display.getDisplay(this);
quitCommand = new Command(Quit, Command.SCREEN,1);
textBox = new TextBox(Hello World, My first MIDLET, 40, 0);
textBox.addCommand(quitCommand);
textBox.setCommandListener(this);
display.setCurrent(textBox);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
Public void commandAction(Command choice, Displayable displayable)
{
If(choice == quitCommand)
{
destroyApp(false);
notifyDestroyed();
}
}
}
J2ME program:b) Immutable image and mutable image

import javax.microedition.midlet.*;
import javax.microedition.lcdui.*;
public class Immut extends MIDLET implements CommandListener
{
private Display d;
private Form f;
private Command exit;
Page 29

private Image img;
private ImageItem ii;
public Immut()
{
d = Display.getDispaly(this);
exit = new Command(Exit, Command.EXIT, 1);
f = new Form(Immutable Example);
f.addCommand(exit);
f.setCommandListener(this);
try
{
img = Image.createImage(/image1.png);
ii = new ImageItem(null, img, ImageItem.LAYOUT_NEWLINE_BEFORE |
ImageItem.LAYOUT_DEFAULT |
ImageItem.LAYOUT_NEWLINE_AFTER, My Image);
f.append(ii);
}
catch( java.io.IOException error)
{
Alert al = new Alert(Error, Cannot load image1.png, null, null);
al.setTimeout(Alert.FOREVER);
al.setType(AlertType.ERROR);
d.setCurrent(al);
}
}
J2ME program:public void startApp()

{
d.setCurrent(f);
}
public void pauseApp()
{
}
public void destroyApp(boolean unconditional)
{
}
public void commandAction(Command command, Dispalyable Displayable)
{
if(command == exit)
{
destroyApp(false);
Page 30

notifyDestroyed();
}
}
}
Page 31
Experiment-8
Title: - Multithreading in LINUX
Aim: - Write a program in C to implement RTOS concept of multithreading and implement it in
LINUX.
Learning Objective: - To unerstand the concepts of thread, process used in Real Time operating
System and implement the same.
Theory:1.
Discuss the features of Linux useful for embedded system design.
2.
What are the various issues in task synchronization?
Algorithm:
Create a thread to read the text entered in lower case.
Create a thread to convert the lower case text into upper case.
Check then whether the thread creation is correct or failed.
The program should keep on converting lower case text to upper case text till input
string is stop
Program should end with the string stop and should not convert it to STOP.
Conclusion:-
Page 32

Multithreading program:#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<pthread.h>
#define BUFFER_SIZE 1024
char buffer[BUFFER_SIZE];
void *read_thread(void *arg) {
while(strncmp("stop",buffer,4) != 0){
printf("enter text:");
fgets(buffer,BUFFER_SIZE, stdin);
sleep(2);
}
pthread_exit("read_thread exit successful");
}
void *convert_thread() {
int i;
while(strncmp("stop",buffer, 4) != 0) {
sleep(3);
printf("converted text:");
for(i=0; i<strlen(buffer); i++)
printf("%c",toupper(buffer[i]));
}
pthread_exit("convert_thread exit successful");
}
int main()
{
int result;
pthread_t rthread,cthread;
void *thread_result;
printf("enter text, the program will convert it into upper case,\n
to stop enter'stop'\n");
result = pthread_create(&rthread, NULL, read_thread, NULL);
if(result != 0) {
printf("read_thread creation failed");
exit(1);
}
Page 33

Multithreading program:result = pthread_create(&cthread, NULL, convert_thread, NULL);
if(result != 0) {
printf("convert_thread creation failed");
exit(1);
}
result = pthread_join(rthread, &thread_result);
if(result != 0) {
printf("read_thread join failed");
exit(1);
}
printf("read_thread joined, %s\n",thread_result);
result = pthread_join(cthread, &thread_result);
if(result != 0) {
printf("convert_thread join failed");
exit(1);
}
printf("convert_thread joined, %s\n",thread_result);
exit(0);
}
Page 34
Experiment-9
Title: - Use of Semaphore in LINUX
Aim: - Write a program in C to implement RTOS concept of semaphore and implement it in
LINUX.
Learning Objective: - To understand the concepts of thread, process used in Real Time
operating System and implements the same.
Theory:- List the Linux functions for IPC: the signal, Multithreading and Semaphore as well as
Message Queue.
Algorithm:
Create a thread to read the text entered in lower case.
Create a thread to convert the lower case text into upper case.
Check then whether the thread creation is correct or failed.
The program should keep on converting lower case text to upper case text till input string
is stop
Program should end with the string stop and should not convert it to STOP.
Conclusion:-
Page 35

Semaphore program:#include<stdio.h>
#include<unistd.h>
#include<stdlib.h>
#include<string.h>
#include<ctype.h>
#include<pthread.h>
#include<semaphore.h>
#define BUFFER_SIZE 1024
sem_t sem;
char buffer[BUFFER_SIZE];
void *read_thread(void *arg) {
while(strncmp("stop", buffer, 4) != 0) {
printf("Enter text: ");
fgets(buffer, BUFFER_SIZE, stdin);
sem_post(&sem);
}
pthread_exit("read_thread exit successful");
}
void *convert_thread() {
int i;
sem_wait(&sem);
while(strncmp("stop" , buffer, 4) != 0 ) {
printf("converted text: ");
for(i=0; i<strlen(buffer); i++)
printf("%c", toupper(buffer[i]));
sem_wait(&sem);
}
pthread_exit("convert_thread exit successful");
}
int main() {
int result;
Page 36

Semaphore program:pthread_t rthread, cthread;
void *thread_result;
result=sem_init(&sem, 0 , 0);
if(result!=0){
printf("semaphore initialization failed");
exit(1);
}
printf("Enter text, the program will convert it into upper case, to stop enter 'stop'\n");
result=pthread_create(&cthread, NULL, convert_thread, NULL);
if(result!=0)
{
printf("convert_thread creation failed");
exit(1);
}
result=pthread_create(&rthread, NULL, read_thread, NULL);
if(result!=0)
{
printf("read_thread creation failed");
exit(1);
}
result=pthread_join(rthread, &thread_result);
if(result!=0)
{
printf("read_thread join failed");
exit(1);
}
printf("read_thread joined, %s\n" , thread_result);
result= pthread_join(cthread, &thread_result);
if(result!=0)
{
printf("convert_thread join failed");
exit(1);
Page 37

Semaphore program:}
printf("convert_thread joined, %s\n", thread_result);
sem_destroy(&sem);
exit(0);
}
OUTPUT:sakec@pc22:~$ ./a.out
Enter text, the program will convert it into upper case, to stop enter 'stop'
Enter text: asdf
Enter text: converted text: ASDF
cc
Enter text: converted text: CC
fgh
Enter text: converted text: FGH
stop
read_thread joined, read_thread exit successful
convert_thread joined, convert_thread exit successful
sakec@pc22:~$
Page 38
Experiment-10
Title: - Tank Monitoring System
Aim: - Using RTOS C-OS/II simulate Tank monitoring system to perform following
operations: Timer, Button, Floats, Printer, Display and Bell
Learning Objective: -Real time embedded system can be designed with C-OS/II RTOS
functions. Various modules of Tank monitoring system are written using these functions. We
understand how the tasks are actually created, the way in which the various tasks communicate
with each other.
Theory:With the help of suitable examples, describe following functions of RTOS C-OS/II :
1. OSInit ( )
2.OSStart ( )
3. OSTaskCreate
4.OS_Event *OSQCreate
5.*OSQPend
6.*OSQPost
7. OSSemPend
8.OSSemPost
9. OSTimeDly
Algorithm: - The various modules in the Tank monitoring system are:

DBGMAIN.C
DATA.C
BUTTON.C
DISPLAY.C
FLOAT.C
LEVELS.C
OVERFLOW.C
PRINT.C
TIMER.C
MAIN.C
PROBSTYL.H
PUBLICS.H
UCOS.H
UCOS186C.H
Conclusion:-
Page 39

TANK CODE:/****************************************************************
MAIN.C
****************************************************************/
/* System Include Files */
#include "os_cfg.h"
#include "ix86s.h"
#include "ucos.h"
#include "probstyl.h"
/* Program Include Files */
#include "publics.h"
/***** vEmbeddedMain ****************************************
This is the main routine for the embedded system.

RETURNS: None.
*/
void vEmbeddedMain (
/*
INPUTS: */
void)
{
/*
LOCAL VARIABLES: */
MAIN.C:SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE
Page 40

/*-------------------------------------------------------------*/
OSInit();
vTankDataInit ();
vTimerInit ();
vDisplaySystemInit ();
vFloatInit ();
vButtonSystemInit ();
vLevelsSystemInit ();
vPrinterSystemInit ();
vHardwareInit ();
vOverflowSystemInit();
OSStart();
/****************************************************************
PRINT.C
****************************************************************/
#include "os_cfg.h"
#include "ix86s.h"
#include "ucos.h"
PRINT.C:#include <stdio.h>
Page 41

/* Local Defines */
#define MSG_PRINT_ALL
0x0020
#define MSG_PRINT_TANK_HIST 0x0010
/* Static Functions */
static far void vPrinterTask (void *p_vData);
/* Static Data */
/* The stack and input queue for the Printer task */
#define STK_SIZE 1024
static UWORD PrinterTaskStk[STK_SIZE];
#define Q_SIZE 10
static OS_EVENT *QPrinterTask;
static void *a_pvQPrinterData[Q_SIZE];
/* Semaphore to wait for report to finish. */

static OS_EVENT *semPrinter;
/* Place to construct report. */
static char a_chPrint[10][21];
PRINT.C:/* Count of lines in report. */
static int iLinesTotal;
Page 42
/* Count of lines printed so far. */

static int iLinesPrinted;
/***** vPrinterSystemInit ***********************************
This routine initializes the Printer system.
RETURNS: None.
*/
void vPrinterSystemInit(
/*
INPUTS: */
void)
{
/*
LOCAL VARIABLES: */
/*-------------------------------------------------------------*/
QPrinterTask = OSQCreate (&a_pvQPrinterData[0], Q_SIZE);
OSTaskCreate (vPrinterTask, NULLP,

(void *)&PrinterTaskStk[STK_SIZE], TASK_PRIORITY_PRINTER);
/* Initialize the semaphore as already taken. */

PRINT.C:semPrinter = OSSemCreate (0);
}
Page 43

/***** vPrinterTask *****************************************
This routine is the task that handles the Printer

RETURNS: None.
*/
static far void vPrinterTask(
/*
INPUTS: */
void *p_vData)
/* Unused pointer to data */
{
/*
LOCAL VARIABLES: */
#define MAX_HISTORY 5
BYTE byErr;
/* Error code back from the OS */
WORD wMsg;
/* Message received from the queue */
int aa_iTime[MAX_HISTORY][4];
/* Time of day */
int iTank;
/* Tank iterator. */
int a_iLevel[MAX_HISTORY];
/* Place to get level of tank. */
PRINT.C:int iLevels;
int i;
/* Number of history level entries */

/* The usual */
/*-------------------------------------------------------------*/
Page 44

/* Keep the compiler warnings away. */
p_vData = p_vData;
while (TRUE)
{
/* Wait for a message. */
wMsg = (int) OSQPend (QPrinterTask, WAIT_FOREVER, &byErr);
if (wMsg == MSG_PRINT_ALL)
{
/* Format 'all' report. */
iLinesTotal = 0;
vTimeGet (aa_iTime[0]);
sprintf (a_chPrint[iLinesTotal++],
"Time: %02d:%02d:%02d",
aa_iTime[0][0], aa_iTime[0][1], aa_iTime[0][2]);
for (iTank = 0; iTank < COUNTOF_TANKS; ++iTank)
{
if (iTankDataGet (iTank, a_iLevel, NULLP, 1) IS 1)
/* We have data for this tank; display it. */
PRINT.C:sprintf (a_chPrint[iLinesTotal++],
" Tank %d: %d gls.", iTank + 1, a_iLevel[0]);
}
"--------------------");
Page 45

sprintf (a_chPrint[iLinesTotal++], " ");
}
else
{
/* Print the history of a single tank. */
iLinesTotal = 0;
iTank = wMsg - MSG_PRINT_TANK_HIST;
iLevels = iTankDataGet (iTank, a_iLevel,
(int *) aa_iTime, MAX_HISTORY);
sprintf (a_chPrint[iLinesTotal++], "Tank %d",
iTank + 1);
for (i = iLevels - 1; i >= 0; --i)
{
" %02d:%02d:%02d %4d gls.",
aa_iTime[i][0], aa_iTime[i][1], aa_iTime[i][2],
a_iLevel[i]);
}
PRINT.C:sprintf (a_chPrint[iLinesTotal++],
"--------------------");
sprintf (a_chPrint[iLinesTotal++], " ");
}
iLinesPrinted = 0;
vHardwarePrinterOutputLine (a_chPrint[iLinesPrinted++]);
Page 46
/* Wait for print job to finish. */

OSSemPend (semPrinter, WAIT_FOREVER, &byErr);
}
}
/***** vPrinterInterrupt ************************************
This routine is called when the printer interrupts.
RETURNS: None.
*/
void vPrinterInterrupt (
/*
INPUTS: */
void)
{
/*
LOCAL VARIABLES: */
PRINT.C:/*-------------------------------------------------------------*/
if (iLinesPrinted IS iLinesTotal)
/* The report is done. Release the semaphore. */
OSSemPost (semPrinter);
else
Page 47

/* Print the next line. */
vHardwarePrinterOutputLine (a_chPrint[iLinesPrinted++]);
}
/***** vPrinter..... ****************************************
This routine is called when a printout is needed. */

void vPrintAll(void)
{
OSQPost (QPrinterTask, (void *) MSG_PRINT_ALL);
}
/*
This routine is called when the user requests printing
a tank level.
*/
PRINT.C:void vPrintTankHistory(int iTank)

{
/* Check that the parameter is valid. */
ASSERT (iTank >= 0 AND iTank < COUNTOF_TANKS);
OSQPost (QPrinterTask,
(void *) (MSG_PRINT_TANK_HIST + iTank));
}
Page 48

/****************************************************************
TIMER.C
****************************************************************/
#include "os_cfg.h"
#include "ix86s.h"
#include "ucos.h"

/* Static Data */
/* Data about the time. */
static int iHours;
static int iMinutes;
TIMER.C:static int iSeconds;
static int iSecondTenths;
/* The semaphore that protects the data. */

static OS_EVENT *SemTime;
/***** vTimerInit *******************************************
This routine initializes the timer data.
RETURNS: None.
*/
Page 49

void vTimerInit (
/*
INPUTS: */
void)
{
/*
LOCAL VARIABLES: */
/*-------------------------------------------------------------*/
/* Initialize the time. */
iHours = 0;
iMinutes = 0;
iSeconds = 0;
iSecondTenths = 0;
TIMER.C:/* Initialize the semaphore that protects the data. */
SemTime = OSSemCreate (1);
}
/***** vTimerOneThirdSecond *********************************
This routine increments the timer stuff.
RETURNS: None.
*/
void vTimerOneThirdSecond (
/*
INPUTS: */
Page 50

void)
{
/*
LOCAL VARIABLES: */
BYTE byErr;
/* Place for OS to return an error. */
/*-------------------------------------------------------------*/
/* Get the time semaphore. */
OSSemPend (SemTime, WAIT_FOREVER, &byErr);
/* Wake up the overflow task */

vOverflowTime();
TIMER.C:/* Update the time of day. */

switch (iSecondTenths)
{
case 0:
iSecondTenths = 3;
break;
case 3:
iSecondTenths = 7;
break;
Page 51

case 7:
iSecondTenths = 0;
++iSeconds;
if (iSeconds IS 60)
{
iSeconds = 0;
++iMinutes;
}
if (iMinutes IS 60)
{
iMinutes = 0;
++iHours;
TIMER.C:}
if (iHours IS 24)
iHours = 0;
/* Let the display know. */

vDisplayUpdate ();
break;
}
/* Give back the semaphore. */

OSSemPost (SemTime);
}
Page 52
/**** vTimeGet *********************************************

This routine gets the time.
RETURNS: None.
*/
void vTimeGet (
/*
INPUTS: */
int *a_iTime)
/* An four-space array in which
to return the time. */

{
TIMER.C:/*
LOCAL VARIABLES: */
BYTE byErr;
/* Place for OS to return an error. */
/*-------------------------------------------------------------*/
/* Get the semaphore. */

OSSemPend (SemTime, WAIT_FOREVER, &byErr);
a_iTime[0] = iHours;
a_iTime[1] = iMinutes;
a_iTime[2] = iSeconds;
a_iTime[3] = iSecondTenths;
Page 53

/* Give back the semaphore. */
OSSemPost (SemTime);
return;
}
Page 54
Experiment-11
CASE STUDY SEMINAR

TITLE:
REQUIREMENT ANALYSIS:
PROGRAM MODELLING TECHNIQUE:
HARDWARE BLOCK DIAGRAM:
SOFTWARE ARCHITECTURE:
TESTING AND FAULT ANALYSIS:
REAL TIME ISSUES AND CHALLENGES:
CONCLUSION:
Page 55

ESD Manual Students

Uploaded by

Document Information

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

ESD Manual Students

Uploaded by

Copyright:

Available Formats

Lab Manual-Embedded System Design, B.E.

EMBEDDED SYSTEM DESIGN

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Lab Manual-Embedded System Design, B.E.-VII, Electronics

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Initialize the PLL system to generate 30 MHZ clock.

Built new project in the keil 4 compiler.

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

: Example Analog to Digital converter

// Description : Display Analog to Digital convert value on terminal program(used UART0

// C compiler : Keil CARM Compiler

// Library for sprintf function

// Library for UART

Lab Manual-Embedded System Design, B.E.-VII, Electronics

// Connect the PLL as the clock source

Lab Manual-Embedded System Design, B.E.-VII, Electronics

// Initialize the system

SCS = 0x03; // select the "fast" version of the I/O ports

// Extract the A/D result

\r",val); // Convert string to display analog value

uart0_puts(s); // Display to Terminal program

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Data Register Contents

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Initialize the system.

SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

: Library for serial communication (UART)

// C compiler : Keil CARM Compiler

#define _PCLK 30000000 // Define PCLK for configuration baudrate

// Calculate for U1DL value

PINSEL0 |= 0x00050000; // Enable rx,tx

// 8 bit data,1 stop bit,no parity bit

U1DLL = u1dl & 0xFF; // U1DL for low byte

// U1DL for high byte

UART Program:SHAH AND ANCHOR KUTCHHI ENGINEERING COLLEGE

Lab Manual-Embedded System Design, B.E.-VII, Electronics

Lab Manual-Embedded System Design, B.E.-VII, Electronics

// 8 bit data,1 stop bit,no parity bit

U0DLL = u0dl & 0xFF; // U0DL for low byte

// U0DL for high byte

Lab Manual-Embedded System Design, B.E.-VII, Electronics

// Description : Example for test module UART0 and UART1

// C compiler : Keil CARM Compiler

// Library for use module UART0,UART1(from jx2148_include floder)

// Library for use printf function(For UART1)

Lab Manual-Embedded System Design, B.E.-VII, Electronics

while(!(PLL0STAT & 0x400)) ; // Wait until PLL Locked

// Connect the PLL as the clock source

// Initialize the system

SCS = 0x03; // select the "fast" version of the I/O ports

UART_0_1.c program:while (1)

Lab Manual-Embedded System Design, B.E.-VII, Electronics

// Send string to UART0

/* vPrinter..... ************************************