Microcontroller and Embedded Systems Laboratory Manual 18CSL48

MICROCONTROLLER AND EMBEDDED SYSTEMS
LABORATORY MANUAL
18CSL48
AMC Engineering College

Bannerghatta Road, Bangalore
PART A
Conduct the following experiments by writing program using

ARM7TDMI/LPC2148 using an evaluation board/simulator and the required
software tool.
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

ENTRY ; Mark first instruction to 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
END ; Mark end of file
Result:
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 regester
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 ; Decreament R1 by 1
BNE loop ; repeat till r1 goes 0
back B back ; jumps back to C code
END
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
NOP
NOP
NOP
BACK B BACK
END ;Mark end of file
Program 3:
Write a program to find factorial of a number.

AREA FACTORIAL , CODE, READONLY
START
MOV r0, #5 ; STORE FACTORIAL NUMBER IN R0
MOV r1,r0 ; MOVE THE SAME NUMBER IN 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
NOP
NOP
NOP
END ;Mark end of file

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

table.
AREA SQUARE , CODE, READONLY
START
LDR R0, = TABLE1 ; Load start address of Lookup table
LDR R2, = 0X40000000
LDR R1,[R2] ; Load no whose square is to be find
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
NOP
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

DCD 0X00000064; SQUARE OF 10=100

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

numbers.
AREA LARGEST , CODE, READONLY
START
LDR R1,=VALUE1 ; LOADS THE ADDRESS
LDR R2,[R1],#4 ; WORD ALIGN T0 ARRAY ELEMENT
LOOP
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
STR R2,[R4] ; STORES THE RESULT IN R2
NOP
NOP
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

AREA SMALLEST , CODE, READONLY

START
LDR R1,=VALUE1 ; LOADS THE ADDRESS OF FIRST VALUE
LOOP
BLS LOOP1 ; IF THE FIRST NUMBER IS < THEN GOTO LOOP1
MOV R2,R4 ; IF THE FIRST NUMBER IS > THEN MOV CONTENT R4 TO R2
LOOP1
STR R2,[R4] ; STORES THE RESULT IN R1
NOP
NOP
NOP
back B back
; ARRAY OF 32 BIT NUMBERS(N=7)
VALUE1
DCD 0X44444444 ;
DCD 0X22222222 ;
DCD 0X11111111 ;
DCD 0X22222222 ;
DCD 0XAAAAAAAA ;
DCD 0X88888888 ;
DCD 0X99999999 ;
AREA DATA2,DATA,READWRITE ; TO STORE RESULT IN GIVEN ADDRESS
RESULT DCD 0X0

Program 8:
Write a program to count the number of ones and zeros in two consecutive
memory locations.
AREA ONEZERO , CODE, READONLY

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
NOP
jmp B jmp
VALUE DCD 0X11111111,0XAA55AA55; TWO VALUES IN AN ARRAY

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

order.
AREA ASCENDING , CODE, READONLY
START

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

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
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
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;
; ARRAY OF 32 BIT NUMBERS IN DATA REGION
DVALUE
DCD 0X00000000 ;

AREA DESCENDING , CODE, READONLY
START
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

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

BGT 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
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;
; ARRAY OF 32 BIT NUMBERS IN DATA REGION
DVALUE
DCD 0X00000000 ;

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

using evaluation version of Embedded 'C' & Keil Uvision-4 tool/compiler.
Study Programs:
1. Program to toggle 8 LED’s which are connected to Port pins P0.16 to
P0.23.
#include <lpc21xx.h>
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.
2. 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.

3. 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

4. Write a program to generate triangular wave using internal DAC.
int count = 0;
int main(void)
{
PINSEL1 = 0x00080000 ; //Select AOUT function for P0.25 , bits[19:18] = [10]
while(1)
{
for(count = 0; count < 1023; count++)
{
DACR = (count<<6);
}
for(count = 1023; count >0; count--)

{
DACR = (count<<6);
}
}
}
Result: Triangular wave is observed on Logic Analyzer.
Syllabus Programs:
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.
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 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 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:
unsigned int var;
void delay(void);
int main ()
{
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;
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 13: 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 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 15: Interface a 4x4 keyboard and display the key code on an LCD.
#include<lpc21xx.h>
#include<stdio.h>
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()
{
init_port(); //port intialisation
delay(3200); //delay
lcd_init(); //lcd intialisation
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

{
IO0CLR = 0x000000FC; // clear the port lines.
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 value assigned to that key is
displayed on LCD
Program 12: Determine Digital output for a given Analog input using Internal
ADC of ARM controller.
#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
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 ++;
}
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
{
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;
}
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.

Microcontroller and Embedded Systems Laboratory Manual 18CSL48

Uploaded by

Copyright:

Available Formats

Microcontroller and Embedded Systems Laboratory Manual 18CSL48

Uploaded by

Document Information

Original Description:

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

Microcontroller and Embedded Systems Laboratory Manual 18CSL48

Uploaded by

Copyright:

Available Formats

MICROCONTROLLER AND EMBEDDED SYSTEMS

AMC Engineering College

Conduct the following experiments by writing program using

AREA ADDITION , CODE, READONLY

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

Write a program to multiply two 16 bit binary numbers.

Write a program to find factorial of a number.

ENTRY ;Mark first instruction to execute

MOV r0, #5 ; STORE FACTORIAL NUMBER IN R0

MOV r1,r0 ; MOVE THE SAME NUMBER IN 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

Write a program to find the square of a number (1 to 10) using look-up

ENTRY ;Mark first instruction to execute

LDR R0, = TABLE1 ; Load start address of Lookup table

LDR R2, = 0X40000000

LDR R1,[R2] ; Load no whose square is to be find

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

;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

DCD 0X00000004; SQUARE OF 2=4

DCD 0X00000009; SQUARE OF 3=9

DCD 0X00000010; SQUARE OF 4=16

DCD 0X00000019; SQUARE OF 5=25

DCD 0X00000031; SQUARE OF 7=49

DCD 0X00000040; SQUARE OF 8=64

DCD 0X00000051; SQUARE OF 9=81

DCD 0X00000064; SQUARE OF 10=100

END ; Mark end of file

Write a program to find the largest/smallest number in an array of 32

ENTRY ;Mark first instruction to execute

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

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

SUBS R5,R5,#1 ; DECREMENT COUNTER

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

; ARRAY OF 32 BIT NUMBERS (N=7)

AREA DATA2,DATA,READWRITE T O STORE RESULT IN GIVEN ADDRESS

RESULT DCD 0X0

END ; Mark end of file

ENTRY ;Mark first instruction to execute

MOV R2,R4 ; IF THE FIRST NUMBER IS > THEN MOV CONTENT R4 TO R2

RESULT DCD 0X0

AREA ONEZERO , CODE, READONLY