RV Institute of Technology and Management

Rashtreeya Sikshana Samithi Trust
RV Institute of Technology and Management®

(Affiliated to VTU, Belagavi)
JP Nagar, Bengaluru – 560076
Department of Computer Science & Engineering
Department of Information Science & Engineering
Course Name: Microcontroller and Embedded Systems Laboratory

Course Code: 18CSL48
IV Semester
2018 Scheme
Prepared By:
Dr. Asha S Manek,
Assistant Professor,
Department of Computer Science and Engineering
RVITM, Bengaluru - 560076
Email: [email protected]
Dr. A. Ajina,
Assistant Professor,
Department of Information Science and Engineering
RVITM, Bengaluru - 560076
Email: [email protected]
RV Institute of Technology & Management®
Institute Vision
Strive to impart quality technical education with global competence and societal
commitment, leading to breakthrough innovations.
Department Vision
To be at the frontier of Computer Science and Engineering with a focus on innovation
and industry needs and to produce global professionals contributing to society.
Department Mission
• To impart world-class education in Computer Science and Engineering through
contemporary pedagogical practices.
• To inculcate quality research leading to innovation through latest tools and various
technical forums.
• To impart technical skills and domain knowledge focusing on emerging areas to
produce industry-ready graduates and entrepreneurs
• To impart knowledge to students in interdisciplinary areas that extend the scope of
computer science for the benefit of society.
Program Educational Objectives (graduates are expected to perform and achieve during
the first few years after graduation.)
PEO 1: Impart strong foundation in solving hardware & software engineering problems and
adapt to the changes in technology through continuous-learning.
PEO 2: Inculcate innovation in new technologies and systems in their key domains thus
encouraging them to pursue higher education and research.
PEO 3: Disseminate their knowledge in advance areas of Computer science to become
industry ready graduates or entrepreneurs.
PEO 4: Exhibit professional ethics & values, effective communication and team work with a
multidisciplinary approach to meet the needs of the society.
Program Specific Objectives (students should be able to do at the time of graduation.)
PSO 1: Analyse the core concepts by Computer Science Engineering for building intensive
systems to improve efficiency with different algorithms and tools.
PSO 2: Able to use professional, managerial and interdisciplinary skills in identifying the
research gaps to develop cost effective and innovative solutions leading to
automation.
IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 2 |47

Program Outcomes (POs)

Engineering knowledge: Apply the knowledge of mathematics, science, engineering
PO1 fundamentals, and an engineering specialization to the solution of complex engineering
problems.
Problem analysis: Identify, formulate, review research literature, and analyze complex
PO2 engineering problems reaching substantiated conclusions using first principles of
mathematics, natural sciences, and engineering sciences.
Design/development of solutions: Design solutions for complex engineering problems
and design system components or processes that meet the specified needs with appropriate
PO3
consideration for the public health and safety, and the cultural, societal, and environmental
considerations.
Conduct investigations of complex problems: Use research-based knowledge and
PO4 research methods including design of experiments, analysis and interpretation of data, and
synthesis of the information to provide valid conclusions
Modern tool usage: Create, select, and apply appropriate techniques, resources, and
PO5 modern engineering and IT tools including prediction and modeling to complex
engineering activities with an understanding of the limitations.
The engineer and society: Apply reasoning informed by the contextual knowledge to
PO6 assess societal, health, safety, legal and cultural issues and the consequent responsibilities
relevant to the professional engineering practice.
Environment and sustainability: Understand the impact of the professional engineering
PO7 solutions in societal and environmental contexts, and demonstrate the knowledge of, and
need for sustainable development.
Ethics: Apply ethical principles and commit to professional ethics and responsibilities and
PO8
norms of the engineering practice.
Individual and team work: Function effectively as an individual, and as a member or
PO9
leader in diverse teams, and in multidisciplinary settings.
Communication: Communicate effectively on complex engineering activities with the
engineering community and with society at large, such as, being able to comprehend and
PO10
write effective reports and design documentation, make effective presentations, and give
and receive clear instructions.
Project management and finance: Demonstrate knowledge and understanding of the
PO11 engineering and management principles and apply these to one’s own work, as a member
and leader in a team, to manage projects and in multidisciplinary environments.
Life-long learning: Recognize the need for, and have the preparation and ability to engage
PO12
in independent and life-long learning in the broadest context of technological change.

Course: Microcontroller & Embedded System Lab Credits: 2
Semester: 4 CIE Marks: 40
Course Code: 18CSL33 SEE Marks: 60
Teaching Hours/Week: 0:2:2 Exam Hours: 03
Academic Year: 2020-21

Course Learning Objectives: This course (18CSL48) will enable students to:
 Develop and test Program using ARM7TDMI/LPC2148
 Conduct the experiments on an ARM7TDMI/LPC2148 evaluation board using evaluation
version of Embedded 'C' & Keil Uvision-4 tool/compiler.
LIST OF PROGRAMS
Sl. No PROGRAMS
PART A - Conduct the following experiments by writing program using
ARM7TDMI/LPC2148 using an evaluation board/simulator and the required software tool.
1 Write a program to multiply two 16-bit binary numbers.
2 Write a program to find the sum of first 10 integer numbers.
3 Write a program to find factorial of a number.
4 Write a program to add an array of 16-bit numbers and store the 32-bit result in internal
RAM
5 Write a program to find the square of a number (1 to 10) using look-up table.
6 Write a program to find the largest/smallest number in an array of 32 numbers.
7 Write a program to arrange a series of 32-bit numbers in ascending/descending order
8 Write a program to count the number of ones and zeros in two consecutive memory
locations.
PART – B Conduct the following experiments on an ARM7TDMI/LPC2148 evaluation board
using evaluation version of Embedded 'C' & Keil Uvision-4 tool/compiler.
9 Display “Hello World” message using Internal UART.
10 Interface and Control a DC Motor.
11 Interface a Stepper motor and rotate it in clockwise and anti-clockwise direction.
12 Determine Digital output for a given Analog input using Internal ADC of ARM
controller.
13 Interface a DAC and generate Triangular and Square waveforms
14 Interface a 4x4 keyboard and display the key code on an LCD.
15 Demonstrate the use of an external interrupt to toggle an LED on/off.
16 Display the Hex digits 0 to F on a 7-segment LED interface, with an appropriate delay
in between
Laboratory Outcomes: The student should be able to:
CO No. Statement
CO1 Develop and test program using ARM7TDMI/LPC2148
CO2 Conduct the following experiments on an ARM7TDMI/LPC2148 evaluation
board using evaluation version of Embedded 'C' & Keil uvision-4
tool/compiler.

Conduct of Practical Examination:

 Experiment distribution
o For laboratories having only one part: Students are allowed to pick one experiment
from the lot with equal opportunity.
o For laboratories having PART A and PART B: Students are allowed to pick one
Experiment from PART A and one experiment from PART B, with equal opportunity.
 Change of experiment is allowed only once and marks allotted for procedure to be made
zero of the changed part only.
 Marks Distribution (Coursed to change in accordance with university regulations)
o For laboratories having only one part – Procedure + Execution + Viva-Voce:
15+70+15 =100 Marks
o For laboratories having PART A and PART B
i. Part A – Procedure + Execution + Viva = 6 + 28 + 6 = 40 Marks
ii. Part B – Procedure + Execution + Viva = 9 + 42 + 9 = 60 Marks
General Instructions to Students:

1. Understand the theoretical concept for the respective experiment.
2. Draw the circuit diagram in the given space in the observation book.
3. Tabulate the readings in the observation book and plot the graphs if necessary.
4. Every Student must at least construct one circuit.
5. After the completion of the experiment, get signature in the observation book.
6. Before coming to next lab, make sure that records will be updated and signed from the
concerned faculty.
Guide Lines for Writing Manual:

Blank Page (USE PENCIL)
Practical No:
Aim:
Circuit Diagram:
Theory:
Procedure:
Calculation:
Result:
Ruled Page (USE PEN)
Practical No:
Aim:
Apparatus Required:
Characteristics/Wave form/ Observation Table:
Result:

Introduction to ARM7
The LPC2141/42/44/46/48 microcontrollers are based on a 16-bit/32-bit ARM7TDMI-S CPU with

real-time emulation and embedded trace support, that combine microcontroller with embedded
high-speed flash memory ranging from 32 kB to 512 kB. A 128-bit wide memory interface and
unique accelerator architecture enable 32-bit code execution at the maximum clock rate. For
critical code size applications, the alternative 16-bit Thumb mode reduces code by more than 30
% with minimal performance penalty. Due to their tiny size and low power consumption,
LPC2141/42/44/46/48 are ideal for applications where miniaturization is a key requirement, such
as access control and point-of sale. Serial communications interfaces ranging from a USB 2.0 Full-
speed device, multiple UARTs, SPI, SSP to I2C-bus and on-chip SRAM of 8 kB up to 40 kB,
make these devices very well suited for communication gateways and protocol converters, soft
modems, voice recognition and low-end imaging, providing both large buffer size and high
processing power. Various 32-bit timers, single or dual 10-bit ADC(s), 10-bit DAC, PWM
channels and 45 fast GPIO lines with up to nine edge or level sensitive external interrupt pins make
these microcontrollers suitable for industrial control and medical systems.
BLOCK Diagram of ARMLPC2148

Step 1: After opening Keil uV4, Go to Project tab and click on close project
Then Create new uVision project
Now Select new folder and give name to Project.
Step 2: After Creating project now Select your device model. Example.NXP-LPC2148
[You can change it later from project window.]

Step 3: so now your project is created and Message window will appear to add start up file of
your Device click on Yes so it will be added to your project folder
Step 4: Now go to File and create new file and save it with .C extension if you will write program
in C language or save with .asm for assembly language.
Step 5: Now write your program and save it again. You can try example given at end of this
tutorial.
Step 6: After that on left you see project window [if it’s not there….go to View tab and click on
project window]
Now come on Project window.

Right click on target and click on options for target
Here you can change your device also.

Click output tab here & check create Hex file if you want to generate hex file
Now click on ok so it will save changes.
Step 7: Now Expand target and you will see source group
Right click on group and click on Add files to source group

Step 9: you can see Status of your program in Build Output window
[If it’s not there go to view and click on Build output window]

PROGRAMS
PART-A
Conduct the following experiments by writing program using
ARM7TDMI/LPC2148 using an evaluation board/simulator and the required
software tool.
Program 1: Write a program to multiply two 16-bit binary numbers.

AREA MULTIPLY, CODE, READONLY
ENTRY ; Mark first instruction to
execute START
MOV r1, #6400 ; STORE FIRST NUMBER IN R0
MOV r2, #3200 ; STORE SECOND NUMBER IN R1
MUL r3, r1, r2 ;MULTIPLICATION
END ; Mark end of file

Program 2: Write a program to find the sum of first 10 integer numbers.

AREA SUM, CODE, READONLY
ENTRY
MOV R1, #10 ; load 10 to register
MOV R2, #0 ; empty the register to store result
loop
ADD R2, R2, R1 ; add the content of R1 with result at R2
SUBS R1, #0x01 ; Decrement R1 by 1

BNE loop ; repeat till r1 goes 0
back B back ; jumps back to C code
END

Program 3: Write a program to find factorial of a number.

AREA FACTORIAL, CODE, READONLY
execute START
MOV r0, #5 ; STORE FACTORIAL NUMBER IN
R0
MOV r1, r0 ; MOVE THE SAME NUMBER TO R1
FACT SUBS r1, r1, #1 ; SUBTRACTION
CMP r1, #1 ; COMPARISON
BEQ STOP
MUL r3, r0, r1 ; MULTIPLICATION
MOV r0, r3 ; Result
BNE FACT ; BRANCH TO THE LOOP IF NOT EQUAL

STOP

Program 4: Write a program to add an array of 16-bit numbers and store the
32-bit result in internal RAM.
AREA ADDITION, CODE, READONLY
execute START
MOV R5, #6 ; INTIALISE COUNTER TO 6(i.e.
N=6)
MOV R0, #0 ; INTIALISE SUM TO ZERO
LDR R1, =VALUE1 ; LOADS THE ADDRESS OF FIRST
VALUE LOOP
LDRH R3, [R1], #02 ; READ 16 BIT DATA
ADD R0, R0, R3 ; ADD R0=R0+R3
SUBS R5, R5, #1 ; DECREMENT COUNTER
CMP R5, #0
BNE LOOP ; LOOK BACK TILL ARRAY ENDS
LDR R4, =RESULT ; LOADS THE ADDRESS OF RESULT
STR R0, [R4] ; STORES THE RESULT IN MEMORY
JMP B JMP
VALUE1 DCW 0X1111, 0X2222, 0X3333, 0XAAAA, 0XBBBB, 0XCCCC
; ARRAY OF 16 BIT NUMBERS (N=6)

AREA DATA2, DATA, READWRITE ; TO STORE RESULT
RESULT DCD 0X0



Program 5: Write a program to find the square of a number (1 to 10) using

look-up table.
AREA SQUARE, CODE, READONLY
ENTRY ; Mark first instruction
START
LDR R0, = TABLE1 ; Load start address of Lookup table
LDR R2, = 0X40000000
LDR R1, [R2] ; Load number whose square is to be
found
MOV R1, R1, LSL#0x2 ; Generate address
ADD R0, R0, R1 ; Load address of element in Lookup table
LDR R3, [R0] ; Get square of given no in R3
NOP
back B back ; Lookup table contains Squares of nos from 0 to 10 (in hex)
TABLE1 DCD 0X00000000; SQUARE OF 0=0
DCD 0X00000001; SQUARE OF 1=1


Program 6: Write a program to find the largest/smallest number in an array

of 32 numbers.
AREA LARGEST, CODE, READONLY
ENTRY ; Mark first instruction to execute
START
MOV R5, #6 ; INTIALISE COUNTER TO 6(i.e. N=7)
LDR R1, =VALUE1 ; LOADS THE ADDRESS
LDR R2, [R1], #4 ; WORD ALIGN T0 ARRAY ELEMENT LOOP
LDR R4, [R1], #4 ; WORD ALIGN T0 ARRAY ELEMENT
CMP R2, R4 ; COMPARE NUMBERS
BHI LOOP1 ; IF THE FIRST NUMBER IS > THEN GOTO LOOP1
MOV R2, R4 ; IF THE FIRST NUMBER IS < THEN MOV CONTENT R4 TO R2
LOOP1
CMP R5, #0 ; COMPARE COUNTER TO 0
BNE LOOP ; LOOP BACK TILL ARRAY ENDS
LDR R4, =RESULT ; LOADS THE ADDRESS OF
RESULT STR R2, [R4] ; STORES THE RESULT IN R2
NOP
back B back ; ARRAY OF 32-BIT NUMBERS (N=7) VALUE1
DCD 0X44444444 ;
DCD 0X22222222 ;
DCD 0X11111111 ;
DCD 0X33333333 ;
DCD 0XAAAAAAAA ;
DCD 0X88888888 ;
DCD 0X99999999 ;

AREA DATA2, DATA, READWRITE ; T O STORE RESULT IN GIVEN ADDRESS
RESULT DCD 0X0

Program 7: Write a program to arrange a series of 32-bit numbers in ascending

/ descending order.
AREA ASCENDING, CODE, READONLY
execute START
MOV R8, #4 ; INTIALISE COUNTER TO 4(i.e.

N=4) LDR R2, =CVALUE ; ADDRESS OF CODE REGION
LDR R3, =DVALUE ; ADDRESS OF DATA REGION
LOOP0
LDR R1, [R2], #4 ; LOADING VALUES FROM CODE REGION
STR R1, [R3], #4 ; STORING VALUES TO DATA REGION

CMP R8, #0 ; COMPARE COUNTER TO 0
BNE LOOP0 ; LOOP BACK TILL ARRAY ENDS

START1 MOV R5, #3 ; INTIALISE COUNTER TO 3(i.e. N=4)
MOV R7, #0 ; FLAG TO DENOTE EXCHANGE HAS
OCCURED LDR R1, =DVALUE; LOADS THE ADDRESS OF FIRST

VALUE
LOOP LDR R2, [R1], #4 ; WORD ALIGN T0 ARRAY
ELEMENT LDR R3, [R1] ; LOAD SECOND NUMBER
CMP R2, R3 ; COMPARE NUMBERS
BLT LOOP2 ; IF THE FIRST NUMBER IS < THEN
GOTO LOOP2 STR R2, [R1], #-4 ; INTERCHANGE NUMBER

R2 & R3 STR R3, [R1] ; INTERCHANGE NUMBER R2 & R3
MOV R7, #1 ; FLAG DENOTING EXCHANGE HAS TAKEN PLACE
ADD R1, #4 ; RESTORE THE PTR
LOOP2
SUBS R5, R5, #1 ; DECREMENT COUNTER CMP
R5, #0 ; COMPARE COUNTER TO 0

BNE LOOP ; LOOP BACK TILL ARRAY ENDS

CMP R7, #0 ; COMPARING FLAG
BNE START1 ; IF FLAG IS NOT ZERO THEN GO TO START1 LOOP
NOP
NOP
NOP
; ARRAY OF 32-BIT NUMBERS (N=4) IN CODE REGION
CVALUE
DCD 0X44444444
DCD 0X11111111
DCD 0X33333333
DCD 0X22222222
AREA DATA1, DATA, READWRITE;
DCD 0X00000000

Program 8: Write a program to count the number of ones and zeros in two
consecutive memory locations.
AREA ONEZERO, CODE, READONLY
ENTRY ;Mark first instruction
to execute START
MOV R2, #0 ; COUNTER FOR ONES
MOV R3, #0 ; COUNTER FOR ZEROS
MOV R7, #2 ; COUNTER TO GET TWO WORDS
LDR R6, =VALUE ; LOADS THE ADDRESS OF

VALUE
LOOP MOV R1, #32 ; 32 BITS COUNTER
LDR R0, [R6], #4 ; GET THE 32-BIT VALUE

LOOP0 MOVS R0, R0, ROR #1 ; RIGHT SHIFT TO CHECK CARRY BIT (1's/0's)
BHI ONES ; IF CARRY BIT IS 1 GOTO ONES BRANCH
OTHERWISE NEXT
ZEROS ADD R3, R3, #1 ; IF CARRY BIT IS 0 THEN INCREMENT THE COUNTER BY 1(R3)
B LOOP1 ; BRANCH TO LOOP1

ONES ADD R2, R2, #1 ; IF CARRY BIT IS 1 THEN INCREMENT THE COUNTER BY 1(R2)
LOOP1 SUBS R1, R1, #1 ; COUNTER VALUE DECREMENTED BY 1
BNE LOOP0 ; IF NOT EQUAL GOTO TO LOOP0 CHECKS 32BIT
SUBS R7, R7, #1 ; COUNTER VALUE DECREMENTED BY 1
CMP R7, #0 ; COMPARE COUNTER R7 TO 0

BNE LOOP ; IF NOT EQUAL GOTO TO LOOP
NOP
NOP
JMP B JMP
VALUE DCD 0X11111111, 0XAA55AA55 ; TWO VALUES IN AN ARRAY


PART –B
Conduct the following experiments on an ARM7TDMI/LPC2148 evaluation

board using evaluation version of Embedded 'C' & Keil Uvision-4
tool/compiler.
Program 9: Display “Hello World” message using Internal UART.

#include<lpc214x.h>
void uart_init(void);
unsigned int delay;
unsigned char *ptr;
unsigned char arr[]="HELLO WORLD\r";
int main ()
{
while (1)
{
uart_init();
ptr = arr;
while (*ptr! ='\0')
{
U0THR=*ptr++;
while (! (U0LSR & 0x40) == 0x40);
for (delay=0; delay<=600; delay++);
}
for (delay=0; delay<=60000; delay++);
}
}
void uart_init(void)
{
PINSEL0=0X0000005; //select TXD0 and RXD0
lines U0LCR = 0X00000083; //enable baud rate divisor
loading U0DLM = 0X00; //select the data format
U0DLL = 0x13; //select baud rate 9600
bps U0LCR = 0X00000003;
}
Result: Hello World will be displayed on terminal.

Program 10: Interface and Control a DC Motor.

Note: DC motor terminals are connected to port pins P0.8 to P0.11.
#include<lpc214x.h>
void clock_wise(void);
void
anti_clock_wise(void);
unsigned int j=0;
int main ()
{
IO0DIR= 0X00000900;
IO0SET= 0X00000100; //P0.8 should always high.
while (1)
{
clock_wise();
for(j=0;j<400000;j++); //delay
anti_clock_wise();
for(j=0;j<400000;j++); //delay
//End of while (1)
}
} //End of Main
void clock_wise(void)
{
IO0CLR = 0x00000900; //stop motor and also turn off relay
for (j=0; j<10000; j++); //small delay to allow motor to turn
off IO0SET = 0X00000900; //Selecting the P0.11 line for
clockwise
}
void anti_clock_wise(void)
{
IO0CLR = 0X00000900; //stop motor and also turn off relay for
(j=0; j<10000; j++); //small delay to allow motor to turn off
IO0SET = 0X00000100; //not selecting the P0.11 line for Anti clockwise
}
Result: DC Motor rotates in Clockwise for a period of time and then in

Anticlockwise direction.

Program 11: Interface a Stepper motor and rotate it in clockwise and anti-
clockwise direction.
Note: Stepper motor is connected to port pins P0.12 to P0.15.
#include <LPC21xx.H>
void clock_wise(void);
void
anti_clock_wise(void);
unsigned long int var1, var2;
unsigned int i=0, j=0, k=0;
int main(void)
{
PINSEL0 = 0x00FFFFFF; //P0.12 to P0.15
GPIo IO0DIR = 0x0000F000; //P0.12 to P0.15 output
while (1)
{
for (j=0; j<50; j++)
clock_wise();
for (k=0; k<65000; k++);
for (j=0; j<50; j++)
anti_clock_wise();
for (k=0; k<65000; k++);

} // End of while (1)
} // End of main
void clock_wise(void)
{
var1 = 0x00000800; //For
Clockwise for (i=0; i<=3; i++) // for A B C
D Stepping
{
var1 = var1<<1; //For
Clockwise IO0PIN = var1;
for (k=0; k<3000; k++); //for step speed variation
}
}

void anti_clock_wise(void)
{
var1 = 0x00010000; //For Anticlockwise
for (i=0; i<=3; i++) // for A B C D
Stepping
{
var1 = var1>>1; //For Anticlockwise
IO0PIN = var1;
for (k=0; k<3000; k++); //for step speed variation
}
}
Result: Stepper Motor rotates 3600 in Clockwise and after a small delay rotates in
3600 in anticlockwise direction.

Program 12: Determine Digital output for a given Analog input using
Internal ADC of ARM controller.
//10-bit internal ADC

//AIN0 pin is selected
//you can change the channel by changing PINSEL1 and ADCR value
#include <lpc214x.h>
#include <Stdio.h>
void lcd_init(void);
void wr_cn(void);
void clr_disp(void);
void delay(unsigned int);
void lcd_com(void);
void wr_dn(void);
void lcd_data(void);
unsigned int data_lcd=0;

unsigned int adc_value=0,temp_adc=0,temp1,temp2;
float temp;
char var[15],var1[15];
char *ptr,arr[]= "ADC O/P= ";
char *ptr1,dis[]="A I/P = ";
#define vol 3.3 //Reference voltage

#define fullscale 0x3ff //10 bit adc
int main()
{
PINSEL1 = 0X00040000; //AD0.4 pin is selected (P0.25)
IO0DIR = 0x000000FC; //configure o/p lines for lcd
delay (3200);
lcd_init(); //LCD initialization
delay (3200);
clr_disp(); //clear display
delay (3200); //delay
ptr = dis;

temp1 = 0x80; //Display starting address of first line 1

th pos
lcd_com();
delay (800);
while (*ptr!='\0')
{
temp1 = *ptr;
lcd_data();
ptr ++;
}
ptr1 = arr;
temp1 = 0xC0; //Display starting address of second
line 4 th pos
lcd_com();
delay (800);
while(*ptr1!='\0')
{
temp1 = *ptr1;
lcd_data();
ptr1 ++;
}
//infinite loop
while (1)
{
//CONTROL register for ADC
AD0CR = 0x01200010; //command register for
ADC-AD0.4
while (((temp_adc = AD0GDR) &0x80000000) == 0x00000000);

//to check the interrupt bit
adc_value = AD0GDR; //reading the ADC value

adc_value >>=6;
adc_value &= 0x000003ff;
temp = ((float)adc_value * (float)vol)/(float)fullscale;
sprintf(var1,"%4.2fV",temp);
sprintf(var,"%3x",adc_value);

temp1 = 0x89;
lcd_com();
delay (1200);
ptr = var1;
while (*ptr!='\0')
{
temp1=*ptr;
lcd_data();
ptr++;
}
temp1 = 0xc9;
lcd_com();
delay(1200);
ptr1 = var;
while (*ptr1!='\0')
{
temp1=*ptr1;
lcd_data();
ptr1++;
}
} // end of while (1)
} //end of main ()
//lcd initialization
void lcd_init()
{
temp2=0x30;
wr_cn();
delay (800);
temp2=0x30;
wr_cn();
delay(800);
temp2=0x30;
wr_cn();
delay (800);

temp2=0x20;
wr_cn();
delay (800);
temp1 = 0x28;
lcd_com();
delay(800);
temp1 = 0x0c;
lcd_com();
delay (800);
temp1 = 0x06;
lcd_com();
delay (800);
temp1 = 0x80;
lcd_com();
delay (800);
}
void lcd_com(void)
{
temp2= temp1 & 0xf0;
wr_cn();
temp2 = temp1 & 0x0f;
temp2 = temp2 << 4;
wr_cn();
delay (500);
}
// command nibble o/p routine

void wr_cn(void) // write command reg
{
IO0CLR = 0x000000FC; // clear the port lines.
IO0SET = temp2; // Assign the value to the PORT lines
IO0CLR = 0x00000004; // clear bit RS = 0
IO0SET = 0x00000008; // E=1
delay (10);
IO0CLR = 0x00000008;

// data nibble o/p routine

void wr_dn(void)
{
IO0SET = temp2; // Assign the value to the PORT lines
IO0SET = 0x00000004; // set bit RS = 1
IO0SET = 0x00000008; // E=1
delay(10);
IO0CLR = 0x00000008;
}
// data o/p routine which also outputs high nibble first

// and lower nibble next
void lcd_data(void)
{
temp2 = temp1 & 0xf0;
wr_dn();
temp2= temp1 & 0x0f;
temp2= temp2 << 4;
wr_dn();
delay (100);
}
void delay(unsigned int r1)

{
unsigned int r;
for(r=0;r<r1;r++);
}
void clr_disp(void)
{
temp1 = 0x01;
lcd_com();
delay (500);
}
Result: Analog values given by Potentiometer (POT) is converted to digital value and
displayed on LCD.

Program 13: Interface a DAC and generate Triangular and Square waveforms.
Note: 8 bit DAC 0800 is connected to port pins P0.16 to P0.23.
Square wave:
#include <lpc21xx.h>
unsigned int var;
void delay(void);
int main ()
{
PINSEL0 = 0x00000000 ; // Configure P0.0 to P0.15 as
GPIO PINSEL1 = 0x00000000 ; // Configure P0.16 to P0.31 as
GPIO IO0DIR = 0x00FF0000 ;
while(1)
{
IO0PIN = 0x00000000;
var= 0x00000000;
delay();
IO0PIN = 0x00FF0000;
var= 0x00FF0000;
delay();
}
}
void delay(void)
{
unsigned int i=0;
for(i=0;i<=950;i++);
}
Result: Square wave can be observed on CRO and also on Logic Analyzer.

Triangular Wave:
#include <LPC21xx.h>
unsigned long int temp=0x00000000;
int main ()
{
unsigned int i=0;
PINSEL0 = 0x00000000 ; // Configure P0.0 to P0.15 as
GPIO PINSEL1 = 0x00000000 ; // Configure P0.16 to P0.31 as
GPIO IO0DIR=0x00FF0000;
while(1)
{
for(i=0;i!=0xFF;i++)
{
temp=i;
temp = temp << 16;
IO0PIN=temp;
}
for(i=0xFF; i!=0;i--)
{
temp=i;
temp = temp << 16;
IO0PIN=temp;
}
}
}
Result: Triangular wave can be observed on CRO and also on Logic Analyzer.

Program 14: Interface a 4X4 keyboard and display the key code on an LCD.
/*Program to demonstrate keyboard operation
Takes a key from key board and displays it on LCD screen*/
#include<lpc21xx.h>
#include<stdio.h>
/******* FUNCTION PROTOTYPE*******/
void lcd_init(void);
void clr_disp(void);
void lcd_com(void);
void lcd_data(void);
void wr_cn(void);
void wr_dn(void);
void scan(void);
void get_key(void);
void display(void);
void delay(unsigned int);
void init_port(void);
unsigned long int scan_code[16]= {0x00EE0000,0x00ED0000,0x00EB0000,0x00E70000,

0x00DE0000,0x00DD0000,0x00DB0000,0x00D70000,
0x00BE0000,0x00BD0000,0x00BB0000,0x00B70000,
0x007E0000,0x007D0000,0x007B0000,0x00770000};
unsigned char ASCII_CODE[16]= {'0','1','2','3',

'4','5','6','7',
'8','9','A','B',
'C','D','E','F'};
unsigned char row,col;
unsigned char temp,flag,i,result,temp1;

unsigned int r,r1;
unsigned long int var,var1,var2,res1,temp2,temp3,temp4;
unsigned char *ptr,disp[] = "4X4 KEYPAD";
unsigned char disp0[] = "KEYPAD TESTING";
unsigned char disp1[] = "KEY = ";
int main()
{
// __ARMLIB_enableIRQ();
init_port(); //port intialisation
delay(3200); //delay
lcd_init(); //lcd intialisation
delay(3200); //delay
clr_disp(); //clear display

delay(500); //delay
//........LCD DISPLAY TEST.........//

ptr = disp;
temp1 = 0x81; // Display starting address
lcd_com();
delay (800);
while (*ptr!='\0')
{
temp1 = *ptr;
lcd_data();
ptr ++;
}
//........KEYPAD Working.........//
while (1)
{
get_key ();
display ();
}
} //end of main()
void get_key(void) //get the key from the keyboard

{
unsigned int i;
flag = 0x00;
IO1PIN=0x000f0000;
while (1)
{
for(row=0X00;row<0X04;row++) //Writing one for col's
{
If (row == 0X00)
{
temp3=0x00700000;
}
else if(row == 0X01)
{
temp3=0x00B00000;
}
{
temp3=0x00D00000;
}
{

temp3=0x00E00000;
}
var1 = temp3;
IO1PIN = var1; // each time var1 value is put to port1
IO1CLR =~var1; // Once again Conforming (clearing all other bits)
scan ();
delay (100); //delay
if (flag == 0xff)
break;
} // end of for
if (flag == 0xff)
break;
} // end of while
for (i=0;i<16;i++)
{
if (scan_code[i] == res1) //equate the scan_code with res1
{
result = ASCII_CODE[i]; //same position value of ascii code
break; //is assigned to result
}
}
}// end of get_key();
void scan(void)
{
unsigned long int t;
temp2 = IO1PIN; // status of port1
temp2 = temp2 & 0x000F0000; // Verifying column key
if(temp2 != 0x000F0000) // Check for Key Press or Not
{
delay (1000); //delay(100)//give debounce delay check again
temp2 = IO1PIN;
temp2 = temp2 & 0x000F0000; //changed condition is same
if (temp2 != 0x000F0000) // store the value in res1

{
flag = 0xff;
res1 = temp2;
t = (temp3 & 0x00F00000); //Verfying Row Write
res1 = res1 | t; //final scan value is stored in res1
}
else
{
flag = 0x00;
}
}

} // end of scan()
void display(void)
{
ptr = disp0;
temp1 = 0x80; // Display starting address of first line
lcd_com();
while (*ptr!='\0')
{
temp1 = *ptr;
lcd_data();
ptr ++;
}
ptr = disp1;
temp1 = 0xC0; // Display starting address of second line
lcd_com();
while (*ptr!='\0')
{
temp1 = *ptr;
lcd_data ();
ptr ++;
}
temp1 = 0xC6; //display address for key value
lcd_com();
temp1 = result;
lcd_data();
}
void lcd_init (void)

{
temp = 0x30;
wr_cn();
delay(3200);
temp = 0x30;
wr_cn();
delay(3200);
temp = 0x30;
wr_cn();
delay(3200);
temp = 0x20;
wr_cn();

delay(3200);
// load command for lcd function setting with lcd in 4 bit mode,
// 2 line and 5x7 matrix display
temp = 0x28;
lcd_com();
delay(3200);
// load a command for display on, cursor on and blinking off

temp1 = 0x0C;
lcd_com();
delay(800);
// command for cursor increment after data dump

temp1 = 0x06;
lcd_com();
delay (800);
temp1 = 0x80;
lcd_com();
delay (800);
}
void lcd_data(void)
{
temp = temp1 & 0xf0;
wr_dn();
temp= temp1 & 0x0f;
temp= temp << 4;
wr_dn();
delay(100);
}
void wr_dn(void) ////write data reg

{
IO0SET = temp; // Assign the value to the PORT lines
IO0SET = 0x00000004; // set bit RS = 1
IO0SET = 0x00000008; // E=1
delay (10);
IO0CLR = 0x00000008;
}
void lcd_com(void)
{
temp = temp1 & 0xf0;

wr_cn();
temp = temp1 & 0x0f;
temp = temp << 4;
wr_cn();
delay(500);
}
void wr_cn(void) //write command reg

{
IO0SET = temp; // Assign the value to the PORT lines
IO0CLR = 0x00000004; // clear bit RS = 0
IO0SET = 0x00000008; // E=1
delay(10);
IO0CLR = 0x00000008;
}
void clr_disp(void)
{
// command to clear lcd display
temp1 = 0x01;
lcd_com();
delay(500);
}
void delay(unsigned int r1)

{
for(r=0;r<r1;r++);
}
void init_port()
{
IO0DIR = 0x000000FC; //configure o/p lines for lcd
IO1DIR = 0XFFF0FFFF;
}
Result: out of 16 keys, one of the key is pressed and values assigned to that key is displayed
on LCD.

Program 15: Demonstrate the use of an external interrupt to toggle an LED On

/Off.
#include<lpc214x.h>
void Extint0_Isr(void) irq; //declaration of ISR
unsigned char int_flag = 0, flag = 0;
int main(void){
IO1DIR = 0X02000000;
IO1SET = 0X02000000;
PINSEL1 =0X00000001; //Setup P0.16 to alternate function EINT0
EXTMODE =0x01; //edge i.e falling edge trigger and active low
EXTPOLAR= 0X00;
VICVectAddr0 = (unsigned long) Extint0_Isr; //Assign the EINT0 ISR function
VICVectCntl0 = 0x20 | 14; //Assign the VIC channel EINT0 to interrupt priority 0
VICIntEnable |= 0x00004000; //Enable the EINT0 interrupt
while (1) //waiting for interrupt to occur
{
if(int_flag == 0x01)
{
if(flag == 0)
{
IO1CLR = 0X02000000;
flag = 1;
}
else if(flag == 1)
{
IO1SET = 0x02000000;
flag = 0;
}
int_flag = 0x00;
}
}
}
void Extint0_Isr(void) irq
{ //whenever there is a low level on
EINT0 EXTINT |= 0x01; //Clear interrupt
int_flag = 0x01;
VICVectAddr = 0; //Acknowledge Interrupt
}
Result: LED connected to port pin P0.25 toggle when external interrupt occurs.

Program 16: Display the Hex digits 0 to F on a 7-segment LED interface, with
an appropriate delay in between.
Note: Seven segment LEDS are connected to port pins P0.16 to P0.23 and select lines of 4 seven
segment LEDS are connected to port pins P0.28 to P0.31.
#include <LPC21xx.h>
unsigned int delay, count=0, Switchcount=0;
unsigned int Disp[16]={0x003F0000, 0x00060000, 0x005B0000, 0x004F0000,
0x00660000,0x006D0000, 0x007D0000, 0x00070000, 0x007F0000, 0x006F0000,
0x00770000, 0x007C0000, 0x00390000, 0x005E0000, 0x00790000, 0x00710000
};
#define ALLDISP 0xF0000000 //Select all display int main (void)

{
PINSEL0 = 0x00000000;
PINSEL1 = 0x00000000;
IO0DIR = 0xF0FF0000;
while (1)
{
IO0SET = ALLDISP; IO0CLR = 0x00FF0000;
for (delay=0;delay<100;delay++);
IO0SET = Disp[Switchcount]; // display the values 0 to F one after the other
for(delay=0;delay<1000000;delay++);
Switchcount++;
if (Switchcount == 16) // after F go back to 0
{
Switchcount = 0;
}
}
}
Result: Numbers 0000, 1111, 2222, …….FFFF is displayed on Seven segment display with
a delay in between.

VIVA QUESTIONS
STUDY OF ARM EVALUATION SYSTEM
1) What are the basic units of ARM 7?

2) What is the address system supported by ARM?
3) Define RISK.
4) What are the instructions used to access the memory in ARM?
5) How are the instructions encoded in ARM machines?
6) What are the basic units of Microprocessor?
7) What is an Instruction?
8) What is clock cycle?
9) Define - RTOS
10) Define – Pipelining
11) What is cache bus?
12) What is cache miss?
13) What is meant by memory mapped I/O?
14) Define – interrupt
15) What is the function of device driver?
16) What is meant by Exception?
17) What is meant by little – endian mode?
18) What is meant by big – endian mode? 19) What is the function of CPSR?
20) What is register - indirect addressing?
21) What are the steps in programming GPIO pins of LPC2148?
22) How to interface an LED with a microcontroller?
23) Explain the PORT pin details of your program.
24) Explain IO0SET and IO0CLR registers.
25) How to disable all the LEDs from being programmed?

CONTENT BEYOND SYLLABUS
Program to toggle 8 LED’s which are connected to Port pins P0.16 to P0.23.
void delay(void);
int main ()
{
PINSEL0 = 0x00000000 ; // Configure P0.0 to P0.15 as GPIO
IO0DIR = 0x00FF0000 ;
while(1)
{
IO0CLR = 0x00FF0000;
delay();
IO0SET = 0x00FF0000;
delay();
}
}
void delay(void)
{
unsigned int i=0,x=0;
for(i=0;i<=95000;i++)
{
for(x=0;x<1000;x++);
}
Result: Eight LED’s toggle (on and off with delay in between) continuously.

Program to beep buzzer which is connected to Port pin P0.9.
void delay(void);
int main ()
{
IO0DIR = 0x00000200 ;
IO0SET = 0x00000200;
delay();
IO0CLR = 0x00000200;
}
void delay(void)
{
unsigned int i=0,x=0;
for(i=0;i<=95000;i++)
{
for(x=0;x<1000;x++);
}
Result: Buzzer beeps for certain period of time and stops.

Write a program to generate square wave using internal DAC.

#include <lpc214x.h> int
count = 0;
int main(void)
{
unsigned int value=0;
PINSEL1 = 0x00080000 ; //Select AOUT function for P0.25 , bits[19:18] = [10]
while(1)
{
for(count = 0; count < 2000; count++)
{
value = 1023;
DACR = (value<<6);
}
for(count = 0; count <2000; count++)

{
value = 0;
DACR = (value<<6);
}
}
}
Result: Square wave is observed on Logic Analyzer

RV Institute of Technology and Management

Uploaded by

Copyright:

Available Formats

RV Institute of Technology and Management

Uploaded by

Document Information

Original Title

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

RV Institute of Technology and Management

Uploaded by

Copyright:

Available Formats

Rashtreeya Sikshana Samithi Trust

RV Institute of Technology and Management®

JP Nagar, Bengaluru – 560076

Department of Computer Science & Engineering

Department of Information Science & Engineering

Course Name: Microcontroller and Embedded Systems Laboratory

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 2 |47

Program Outcomes (POs)

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 3 |47

Course: Microcontroller & Embedded System Lab Credits: 2

Semester: 4 CIE Marks: 40

Course Code: 18CSL33 SEE Marks: 60

Teaching Hours/Week: 0:2:2 Exam Hours: 03

Academic Year: 2020-21

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 4 |47

Conduct of Practical Examination:

General Instructions to Students:

Guide Lines for Writing Manual:

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 5 |47

The LPC2141/42/44/46/48 microcontrollers are based on a 16-bit/32-bit ARM7TDMI-S CPU with

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 6 |47

Then Create new uVision project

Now Select new folder and give name to Project.

[You can change it later from project window.]

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 7 |47

Now come on Project window.

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 8 |47

Right click on target and click on options for target

Here you can change your device also.

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 9 |47

Now click on ok so it will save changes.

Right click on group and click on Add files to source group

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 10 |47

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 11 |47

Program 1: Write a program to multiply two 16-bit binary numbers.

END ; Mark end of file

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 12 |47

Program 2: Write a program to find the sum of first 10 integer numbers.

ADD R2, R2, R1 ; add the content of R1 with result at R2

SUBS R1, #0x01 ; Decrement R1 by 1

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 13 |47

Program 3: Write a program to find factorial of a number.

ENTRY ; Mark first instruction to

MOV r0, #5 ; STORE FACTORIAL NUMBER IN

MOV r1, r0 ; MOVE THE SAME NUMBER TO R1

FACT SUBS r1, r1, #1 ; SUBTRACTION

CMP r1, #1 ; COMPARISON

MUL r3, r0, r1 ; MULTIPLICATION

MOV r0, r3 ; Result

BNE FACT ; BRANCH TO THE LOOP IF NOT EQUAL

END ; Mark end of file

IV-Semester, MC&ES Lab Manual (18CSL48) P a g e 14 |47

LDRH R3, [R1], #02 ; READ 16 BIT DATA

ADD R0, R0, R3 ; ADD R0=R0+R3

SUBS R5, R5, #1 ; DECREMENT COUNTER

BNE LOOP ; LOOK BACK TILL ARRAY ENDS

LDR R4, =RESULT ; LOADS THE ADDRESS OF RESULT

STR R0, [R4] ; STORES THE RESULT IN MEMORY

; ARRAY OF 16 BIT NUMBERS (N=6)