MES LABORATORY Manual 2020

Microcontroller & Embedded Systems 18CSL48
Introduction
LPC-P2148 Features
LPC-P2148is prototype board forLPC2148 ARM7TDMI-S microcontroller with USB 2.0 Full-speed device,
multiple UARTs, SPI, SSP to I2C-bus and on-chip SRAM up to 40 kB, produced by NXP Semiconductors.
With LPC-P2148 you can explore the features of LPC21XX family on budged, the board has everything
necessary to build simple applications: reset and oscillator circuits, JTAG port for programming and debugging,
USB, RS232, SD/MMC, Buzzer, three status LEDs, potentiometer and two user buttons. There are plenty of
GPIOs on extension headers and also a prototype area where you can connect your additional circuits.
 16-bit/32-bit ARM7TDMI-S microcontroller in a tiny LQFP64 package.

 8 kB to 40 kB of on-chip static RAM and 32 kB to 512 kB of on-chip flash memory. 128-bit wide
interface/accelerator enables high-speed 60 MHZ operation.
 In-System Programming/In-Application Programming (ISP/IAP) via on-chip boot loader software.
 Single flash sector/full chip erase in 400 ms and programming of 256 bytes in 1 ms.
 USB 2.0 Full-speed compliant device controller with 2 kB of endpoint RAM. In addition, the LPC2146/48
provides 8 kB of on-chip RAM accessible to USB by DMA.
 One or two (LPC2141/42 vs. LPC2144/46/48) 10-bit ADCs provide a total of 6/14 analog inputs, with
conversion times as low as 2.44 μs per channel.
 Single 10-bit DAC provides variable analog output (LPC2142/44/46/48 only).
 Two 32-bit timers/external event counters (with four capture and four compare channels each), PWM unit (six
outputs) and watchdog.
 Low power Real-Time Clock (RTC) with independent power and 32 kHz clock input. Multiple serial interfaces
including two UARTs (16C550), two Fast I2C-bus (400 kbit/s), SPI and SSP with buffering and variable
data length capabilities.
 Vectored Interrupt Controller (VIC) with configurable priorities and vector addresses.
 Up to 45 of 5 V tolerant fast general purpose I/O pins in a tiny LQFP64 package. Up to 21 external interrupt
pins available.
 On-chip integrated oscillator operates with an external crystal from 1 MHz to 25 MHZ.
 Power saving modes include Idle and Power-down.
 Individual enable/disable of peripheral functions as well as peripheral clock scaling for additional power
optimization.
 Processor wake-up from Power-down mode via external interrupt or BOD.
 Single power supply chip with POR and BOD circuits:
 CPU operating voltage range of 3.0 V to 3.6 V (3.3 V ± 10 %) with 5 V tolerant I/O pads.
Software Tool
Keil MDK-ARM™ is a complete software development toolkit for ARM processor-based microcontrollers. It is
the right choice for embedded applications based on the ARM Cortex™-M series, ARM7™, ARM9™, and
Cortex-R4 processors.
Dept. of Computer Science & Engineering , SJBIT Page 1

Fig 1:Components Details of Online Board

Fig 3: Architecture Diagram of LPC2148

Fig 4: Pin Diagram of LPC 2148

1. Develop an Assembly Language Programs to test Data Transfer Instructions.
AREA ALP1, CODE, READONLY

ENTRY
LDR R5, =5
LDR R7, =8
MOV r7, r5
MVN r7, r5
STOP B STOP
END
2. Develop an Assembly Language Programs to test Arithmetic Operations.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x00000002
LDR r2, =0x00000001
ADD r0, r1, r2
ADD r0, r1, r1, LSL #1
SUB r0, r1, r2
STOP B STOP
END
3. Develop an Assembly Language Programs to test Reverse subtraction.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x00000077
RSB r0, r1, #0 ; RSB subtracts r1 from constant value #0 r0= -r1 (performs 2's complement)
STOP B STOP
END
4. Develop an Assembly Language Programs to test logical operations.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x02040608
LDR R2, =0x10305070
ORR r0, r1, r2
AND r0, r1, r2
EOR r0, r1, r2
BIC r0, r1, r2
STOP B STOP
END

5. Develop an Assembly Language Programs to test Load and store instructions.

ENTRY
LDR R0, =0x40000000
LDR R1, [R0]
LDR R2, =0x40000050
STR R1, [R2]
STOP B STOP
END
6. Develop an Assembly Language Programs to test for carry flag c in CPSR.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x80000004
LDR R3, =0x00000001
MOVS R0, R1, LSL #1
SUBS R1, R3, #1
STOP B STOP
END
7. Develop an Assembly Language Programs to test MOVS and MOVCS instructions.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x80000004
MOVS R0, R1, LSL #1
MOVCS R0, R1 ; if carry is set then R0:=R1
STOP B STOP
END
8. Develop an Assembly Language Programs to test ADDCS instruction.

ENTRY
LDR R0, =0x00000000
LDR R1, =0x80000004
MOVS R0, R1, LSL #1
ADDCS R2, R0, R1
STOP B STOP

END
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.
;/* PROGRAM TO MULTIPLY TWO 16BIT NUMBERS */

;/* VALUE1: 1900H (6400) (IN R1) */
;/* VALUE2: 0C80H (3200) (IN R2) */
;/* RESULT: 1388000H(20480000) (IN R3) */
;/* SET A BREAKPOINT AT NOP INSTRUCTION,RUN THE PROGRAM & CHECK THE RESULT*/
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
END ;Mark end of file

2. Write a program to find the sum of first 10 integer numbers.
AREA SUM10, CODE, READONLY

START
MOV R0, #10

MOV R1, #00
LOOP
ADD R1, R1, R0
SUBS R0, R0, #1
BNE LOOP
STOP B STOP
END

3. Write a program to find factorial of a number.
PROGRAM TO FIND FACTORIAL OF A GIVEN NUMBER
; In this example we have taken n=7
; Check the result in R2/R1 register =13B0H (5040) */
AREA FACTORIAL, CODE, READONLY

START
MOV R0, #7
MOV R1, #1
LOOP
MUL R2, R1, R0
MOV R1, R2
SUBS R0, R0, #1
BNE LOOP
STOP B STOP
END

4. Write a program to add an array of 16 bit numbers and store the 32 bit result in internal RAM
;/* PROGRAM TO ADD an array of 16BIT NUMBERS & STORE IN INTERNAL RAM*/
;/*ARRAY OF 6 NUMBERS0X1111,0X2222,0X3333,0XAAAA,0XBBBB,0XCCCC */
;/* THE SUM IS 29997H THE RESULT CAN BE VIEWED IN LOCATION 0X40000000 & ALSO IN R0*/
;/* SET A BREAKPOINT AT NOP INSTRUCTION,RUN THE PROGRAM & CHECK THE RESULT */
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
LDR R2, [R1], #2 ; WORD ALIGN T0 ARRAY ELEMENT
ADD R0, R0, R2 ; ADD THE ELEMENTS
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 R1
NOP
NOP
NOP
VALUE1 DCW 0X1111, 0X2222, 0X3333, 0XAAAA, 0XBBBB, 0XCCCC ; Array oF 16 bit numbers(N=6)
AREA DATA2, DATA, READWRITE ; TO STORE RESULT IN GIVEN ADDRESS
RESULT DCD 0X0

END ; Mark end of file
5. Write a program to find the square of a number (1 to 10) using look-up table.

;/* Assembly Program to find square of Number */
;/* GIVEN NUMBER IS 6 (R1) THEN RESULT IS IN R3=24H(36) */
;/* SET A BREAKPOINT AT NOP INSTRUCTION,RUN THE PROGRAM & CHECK THE RESULT*/
AREA SQUARE, CODE, READONLY

ENTRY ; Mark first instruction to execute
MOV R2, #00

MOV R1, #7 ;Load no whose square is to be find
LDR R0, =LOOKUP ; Load start address of Lookup table
LDRB R2, [R0, R1] ; Get square of given no in R2
STOP B STOP ; Lookup table contains Squares of no’s from 0 to 10 (in hex)
LOOKUP DCB 0,1,4,9,16,25,36,49,64,81,100
END
6 . a)Write a program to find the largest number in an array of 32 numbers.

;/* PROGRAM TO FIND LARGEST NUMBER IN AN ARRAY & STORE IN INTERNAL RAM*/
;/* ARRAY OF 7 NUMBERS 0X44444444 ,0X22222222,0X11111111,0X33333333,0XAAAAAAAA */
;/* 0X88888888 ,0X99999999 */
;/* RESULT CAN BE VIEWED IN LOCATION 0X40000000 & ALSO IN R2 */
AREA LARGEST , CODE, READONLY

START
MOV R5,#6 ; INTIALISE COUNTER TO 6(i.e. N=7)
LDR R1,=VALUE1 ; LOADS THE ADDRESS OF FIRST VALUE
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
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 R1
NOP
NOP
NOP
; 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 ; TO STORE RESULT IN GIVEN ADDRESS
RESULT DCD 0X0
6 b) Write a program to find the smallest number in an array of 32 numbers.

;/* PROGRAM TO FIND SMALLEST NUMBER IN AN ARRAY & STORE IN INTERNAL RAM */
;/* ARRAY OF 7 NUMBERS 0X44444444 ,0X22222222,0X11111111,0X22222222,0XAAAAAAAA*/
;/* 0X88888888 ,0X99999999 */
;/* RESULT CAN BE VIEWED IN LOCATION 0X40000000 & ALSO IN R2 */
AREA SMALLEST , CODE, READONLY

START
LDR R1,=VALUE1 ; LOADS THE ADDRESS OF FIRST VALUE
LOOP
CMP R2, R4 ; COMPARE NUMBERS
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
SUBS R5, R5,#1 ; DECREMENT COUNTER
CMP R5, #0 ; COMPARE COUNTER TO 0
LDR R4, =RESULT ; LOADS THE ADDRESS OF RESULT
STR R2, [R4] ; STORES THE RESULT IN R1
NOP
NOP
NOP
; 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

7. A) Write a program to arrange a series of 32 bit numbers in ascending order.

;/* array of 4 numbers 0x44444444 ,0x11111111,0x33333333,0x22222222 */

;/* set a breakpoint at start1 lable & run the program */
;/* check the unsorted numbers at location 0x40000000 next */
;/* set a breakpoint at nop instruction,run the program & check the result */
;/* result can be viewed at location 0x40000000 */
AREA SORT, CODE, READONLY

START
MOV R1, #5 ; INTIALISE COUNTER TO 5(i.e. N=5)
OUTLOOP MOV R3, R1

LDR R0, =0x40000000 ; LOADS THE ADDRESS OF FIRST VALUE
INLOOP LDR R2, [R0], #4 ; WORD ALIGN T0 ARRAY ELEMENT

LDR R4, [R0] ; LOAD SECOND NUMBER
CMP R4, R2 ; COMPARE NUMBERS
BCS SKIP ; IF THE FIRST NUMBER IS < THEN GOTO LOOP2
STR R2, [R0], #-4 ; INTERCHANGE NUMBER R2 & R0

STR R4, [R0], #4 ; INTERCHANGE NUMBER R4 & R0
SKIP SUBS R3, R3, #1 ; DECREMENT COUNTER

BNE INLOOP ; LOOP BACK TILL ARRAY ENDS
SUBS R1, R1, #1
BNE OUTLOOP
STOP B STOP
b) Write a program to arrange a series of 32 bit numbers in descending order.

;/* PROGRAM TO sort in Descending order */
;/* ARRAY OF 4 NUMBERS 0X44444444 ,0X11111111,0X33333333,0X22222222 */
;/* SET A BREAKPOINT AT START1 LABLE & RUN THE PROGRAM */
;/* CHECK THE UNSORTED NUMBERS AT LOCATION 0X40000000 NEXT */
;/* RESULT CAN BE VIEWED AT LOCATION 0X40000000 */
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
CMP R2,R3 ; COMPARE NUMBERS
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
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 ;
DVALUE
DCD 0X00000000 ; ARRAY OF 32 BIT NUMBERS IN DATA

REGION

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

START
LDR R0, =0x40000050
LDRH R1, [R0]
MOV R2, #16
LOOP
MOVS R1, R1, LSR #1
ADDCS R3, #1 ; number of ones in R3
ADDCC R4, #1 ;NUMBER of zeros in R4
SUBS R2, #1 ;Decrement counter
BNE LOOP
STOP B STOP
END
PART B
Conduct the following experiments on an ARM7TDMI/LPC2148 evaluation board using Evaluation version
of Embedded 'C' & Kiel Uvision-4 tool/compiler.
9. Display “Hello World” message using Internal UART.

//******************************************************************************
// FileName : 8-bit LCD Programming using Port-1
// Microcontroller : LPC2148
// Compiler : Keil v-4
// Target Hardware : ARM7 Development Board
// Description :Printing some character in LCD using LPC2148 controller
// Pin Connection :`lcd dataline (d0 to d7) connected to port-1 pins of p1.16 to p1.23 respectively an
//Rs(Register Select) pin of LCD connected to P1.24 and
//En(Enable) pin of LCD connected to P1.25
//R/W pin of LCD always ground
//******************************************************************************
#include<lpc214x.h> // Header file for LPC2148
//*************** Function Declaration **************//
void delay(void);
void LCD_init(void);
void LCD_cmd(char cmd);
void LCD_data(char data);
void LCD_string(char *ptr);

//*************** END ofFunction Declaration **************//

//*************** MAIN Program **************//
int main()
{
PINSEL2 = 0x00000000; //P1.16 to P1.31 configured as GPIO
IODIR1 = 0x03FF0000; //P1.16 to P1.25 configured as output port
LCD_init(); // Function call
while(1)
{
LCD_cmd(0x80); //LCD row 1st selection
LCD_string(" Welcome to ");//for multiple charactors(String) to be printed on the display
LCD_cmd(0xC0); //LCD 2nd row selection
LCD_string(" PESIT ");//for multiple charactors(string) to be printed on the display
}
}
//*************** END of MAIN Program **************//

//*************** Delay Program **************//
void delay(void)
{
unsigned int i, j;
for(i = 0 ; i < 1000 ; i++)
for(j = 0 ; j < 500 ; j++);
}
//*************** END of Delay Program **************//

//*************** LCD initilization Program **************//
void LCD_init()
{
LCD_cmd(0x38); //selection of the 8-data lines, 0x28 for 4-bit data
LCD_cmd(0x0C); //Display ON cursor OFF
LCD_cmd(0x06); //move the cursor right
LCD_cmd(0x01); //clear the LCD
// LCD_cmd(0x80); //firat line starting address
}
//*************** END of LCD initilization Program **************//

//*************** LCD Command Program **************//

void LCD_cmd(char cmd)
{
IOCLR1 = 0x03FF0000; // P1.16 to P1.25 port pin made as low for clearing the data
IOSET1 = cmd << 18 | 0x00020000; // cmd varible content data hasbeen shifted 16-times and ORed
with 0x02000000 and result copied to the IOSET1 reg.
delay(); // Function call
}
//*************** END of LCD Command Program **************//

//*************** LCD DATA Program **************//
void LCD_data(char data)

{
IOSET1 = data << 18 | 0x00030000; // data varible content data hasbeen shifted 16-times and
ORed with 0x03000000 and result copied to the IOSET1 reg.
delay(); // Function call IOCLR1 = 0x03FF0000;
// P1.16 to P1.25 port pin made as low for clearing the data
}
//*************** END of LCD DATA Program **************//

//*************** LCD string Program **************//
void LCD_string(char *ptr)
{
while(*ptr)
LCD_data(*ptr++);
}
//*************** END of LCD string Program **************//

10. Interface and Control a DC Motor.
//******************************************************************************
// FileName : DC motor Programming using Port-1
// Description :DC motor rotating clockwise and anticlockwise direction
// Pin Connection :P1.30 and P1.31 pins of Port-0 connected to L293D IC(DC motor driver)
//******************************************************************************

//*************** Function Declaration **************//
void delay(void);
void dc_clock(void);
void dc_A_clock(void);
//*************** MAIN Program **************//
int main()
{
PINSEL2 = 0x00000000; // P1.0 to P1. 31 configured as GPIO
IODIR1 = 0xFFFF0000; // P1.16 to P1. 31 configured as ouput port
while(1)

{
dc_A_clock(); // Function calling
delay();delay();delay();
dc_clock();
delay();delay();delay(); // Function calling
}
}

//*************** Delay Program **************//
void delay(void) // Delay Sub program
{
unsigned int i,j;
for(i=0;i<1000;i++)
for(j=0;j<2000;j++);
}

//*************** DC motor Program **************//
void dc_A_clock(void) // DC-motor anticlockwise rotation Sub program

{
IOSET1 = 0x80000000;
delay();
IOCLR1 = 0x80000000;
delay();
}
void dc_clock(void) // DC-motor anticlockwise rotation Sub program
{
IOSET1 = 0x20000000;
delay();
IOCLR1 = 0x20000000;
delay();
}
//*************** END of DC motor Program **************//

11. Interface a Stepper motor and rotate it in clockwise and anti-clockwise direction.
//******************************************************************************
// FileName : Stepper Motor Programming using Port-1
// Description :Stepper Motor Roatating Clockwise direction after certain
delay roatating Anticlockwise direction
// Pin Connection :P1.28 to P1.31 connected to Stepper motor driver(ULN2003/2803)
//******************************************************************************

//**** Function Declaration ********//
void delay(void);
void stepper_clock(void);
void stepper_A_clock(void);

//*************** MAIN Program **************//
int main()
{
PINSEL2 = 0x00000000; // P1.16 to P1.31 configured as GPIO
IODIR1 = 0xFF << 26; // P1.16 to P1.31 configured as ouput port
while(1)
{
stepper_clock(); // Function calling (P1.28 to P1.31 port pins connected to stepper motor)
delay();
stepper_A_clock();
delay(); // Function calling (P1.28 to P1.31 port pins connected to stepper motor)
}
}

//*************** Delay Program **************//
void delay(void)
{
unsigned int i,j;
for(i=0;i<1000;i++)
for(j=0;j<1000;j++);

}

//*************** Stepper MOtor Clockwise and Anti clockwise Program **************//
void stepper_A_clock(void) //Stepper Motor Clockwise subprogram
{
unsigned int i;
for(i=0;i<5;i++)
{
IOSET1 = 0x9 << 26;
delay();
IOCLR1 = 0x9 << 26;
delay();
IOSET1 = 0xC << 26;
delay();
IOCLR1 = 0xC << 26;
delay();
IOSET1 = 0x6 << 26;
delay();
IOCLR1 = 0x6 << 26;
delay();
IOSET1 = 0x3 << 26;
delay();
IOCLR1 = 0x3 << 26;
delay();
}
}
void stepper_clock(void) //Stepper Motor A_Clockwise subprogram
{
unsigned int i;
for(i=0;i<5;i++)
{
IOSET1 = 0x3 << 26;
delay();
IOCLR1 = 0x3 << 26;
delay();
IOSET1 = 0x6 << 26;
delay();
IOCLR1 = 0x6 << 26;
delay();
IOSET1 = 0xC << 26;

delay();
IOCLR1 = 0xC << 26;
delay();
IOSET1 = 0x9 << 26;
delay();
IOCLR1 = 0x9 << 26;
delay();
IOSET1 = 0x3 << 26;
delay();
IOCLR1 = 0x3 << 26;
delay();
}
}
//*************** END of Stepper MOtor Clockwise and Anti clockwise Program **************//

12. Determine Digital output for a given Analog input using Internal ADC of ARM controller.
//******************************************************************************
// FileName : ADC and LCD Programming
// Description :Analog Signals Are Converted Into Digital Form And Result Printed In Lcd
// Pin Connection :LCD dataline (D0 to D7) connected to Port-1 pins of P1.16 to P1.23 respectively and
//Rs(Register Select) pin of LCD connected to P1. and
//En(Enable) pin of LCD connected to P1.25
//R/W pin of LCD always ground
//ADC channel Connected to Sensors or Resistor Pot. ADC cahnnels are - (P0.30, P0.29, P0,28, P0.25)
//******************************************************************************
#include<lpc214x.h>
#include<string.h>
void delay(void);
void LCD_init(void);
void LCD_cmd(char cmd);
void LCD_data(char data);
void LCD_string(char *ptr);
void adc_channel_select(unsigned int channel);
void adc(void);
void hex_dec(unsigned int lcd_data);
//********************* MAIN Program ******************//
int main()
{
PINSEL1 = 0x01000000; // ADC cinfigure (P0.30, P0.29, P0,28, P0.25), remaining as GPIO
IODIR1 = 0x03FF0000; // P1.16 to P1.25 configured as 0utput port
LCD_init(); // LCD-init function calling
LCD_cmd(0x01); // clear the display
LCD_cmd(0x80); // LCD row one selection
LCD_string("*** Welcome to ***"); // sting of data sent
LCD_cmd(0xC0); // LCD row second selection
LCD_string("*V V Tech*"); // sting of data sent
while(1)
{
adc(); // adc function calling
}
}
// ******************** END of MAIN Program *********************//
// ******************** DELAY Program *********************//
void delay()
{
unsigned int i, j;
for(i = 0 ; i < 1000 ; i++)
for(j = 0 ; j < 1000 ; j++);
}
// ******************** END of DELAY Program *********************//
// ******************** LCD initilization Program *********************//
void LCD_init()
{
LCD_cmd(0x38); //selection of the 8-data lines, 0x28 for 4-bit data
LCD_cmd(0x0C); //Display ON cursor OFF
LCD_cmd(0x06); //move the cursor right
LCD_cmd(0x01); //clear the LCD
LCD_cmd(0x80); //firat line starting address
}
// ******************** END of LCD-init Program *********************//
// ******************** LCD CMD Program *********************//
void LCD_cmd(char cmd)

{
IOSET1 = cmd << 18 | 0x02<<16; // cmd varible content data hasbeen shifted 18-times and
//ORed with 0x02000000 and result copied to the IOSET1 reg.
delay();
}
// ******************** END of LCD CMD Program *********************//
// ******************** LCD data Program *********************//
void LCD_data(char data)
{
IOSET1 = data << 18 | 0x03<<16; // data varible content data hasbeen shifted 18-times and ORed with
//0x03000000 and result copied to the IOSET1 reg.
delay();

}
// ******************** END of LCD data Program *********************//

// ******************** LCD string Program *********************//
void LCD_string(char *ptr)

{
while(*ptr)
LCD_data(*ptr++);
}
// ******************** END of LCD string Program *********************//

// ******************** ADC channel selection sub Program *********************//
void adc_channel_select(unsigned int channel)

{
switch(channel)
{
case 1:AD0CR=0x01200402; //channel 1 selecting
break;
case 2:AD0CR=0x01200404; //channel 2 selecting
break;
default:break;
}
}
// ******************** END of ADC chan sub Program *********************//
// ******************** ADC Program *********************//
void adc()
{
unsigned int temp, ldr, voltage;
// Variables
LCD_cmd(0x01); // clear the display
LCD_cmd(0x80); // LCD row one selection
LCD_string("Temp:"); // printing in LCD as S_1:
adc_channel_select(1); // selection of ADC channel-2
while(!(AD0GDR&0x80000000)); // checking for DONE bit high or not
temp = (AD0GDR & 0x0000FFC0) >> 6; // take the result value from AD0GDR, Masking,
// Right shift 6 times and store it in variable
hex_dec(temp); // Convert result value into ASCII/ decimal Value
delay();
LCD_cmd(0xC8);
voltage=temp*0.003;
LCD_cmd(0xC0); // LCD second row selection
LCD_string("Light:");
adc_channel_select(2); //selection of ADC channel 3
while(!(AD0GDR&0x80000000)); //checking for DONE bit high or not
ldr = (AD0GDR & 0x0000FFC0) >> 6; //take the result value from AD0GDR, Masking,
//Right shift 6 times and store it in variable
hex_dec(ldr); //Convert result value into ASCII/ decimal Value
delay();
// if(temp>45)
// {
// LCD_cmd(0xD4);
// LCD_string("Temperature is high ");
// }
// else
// {
// LCD_cmd(0xD4);
// LCD_string(" ");
// }
//
// if(ldr<250)
// {
// LCD_cmd(0xD4);
// LCD_string("Light Intensity Low ");
// }
// else
// {
// LCD_cmd(0xD4);
// LCD_string(" ");
// }
//
// if(gas>750)
// {
// LCD_cmd(0xD4);
// LCD_string(" Gas Detected ");
// }
// else
// {
// LCD_cmd(0xD4);

// LCD_string(" ");
// }
}
// ******************** END of ADC Program *********************//
// ******************** CONVERTION Program *********************//
void hex_dec(unsigned int lcd_data) //Hex to decimal conversion

{
unsigned int d1,d2,d3,d4;
d1 = lcd_data % 0x0a; //Modulus operation, reminder value stored in variable
lcd_data = lcd_data / 0x0a; //Division operation, quotient value stored in the variable
d2 = lcd_data % 0x0a;
lcd_data = lcd_data / 0x0a;
lcd_data = lcd_data / 0x0a;
LCD_data(d4+0x30); //Data to be displayed on LCD
}
// ******************** END of CONVERTION Program *********************//

13. a) Interface a DAC and generate Triangular and Square waveforms.

#include <LPC214x.h>
unsigned int value;
int main()
{
PINSEL1=0x00080000; // Enable AOUT the DAC Now we simply need to access the //DACR
register and provide the values there is nothing to //enable/disable
now.
// The value needs to be 10 bit wide which should be inside
//the 6-15 bits from 0-0x3FF we can generate the DAC.
while(1)
{
value = 0;
while ( value != 1023 )
{
DACR = ( (1<<16) | (value<<6) );
value++;
}
while ( value != 0 )
{
DACR = ( (1<<16) | (value<<6) );
value--;
}
}
return 0;
}

13.b) Interface a DAC and generate Square waveforms.
#include <LPC214x.h>
void delay(void);
unsigned int value;
int main()
{
PINSEL1=0x00080000; // Enable AOUT the DAC
// Now we simply need to access the DACR register and
//provide the values there is nothing to enable/disable now.
// The value needs to be 10 bit wide which should be
// inside the 6-15 bits from 0-0x3FF we can generate the DAC.
while(1)
{
value = 0;
DACR = ( (1<<16) | (value<<6) );
delay();
value = 1023;
DACR = ( (1<<16) | (value<<6) );
delay();
}
return 0;
}
void delay()
{ int i;
for (i=0; i<2000;i++)
{
;
}
}

14. Interface a 4x4 keyboard and display the key code on an LCD.
//******************************************************************************
// FileName : 8-bit LCD Programming using Port-1
// Description :Printing some character in LCD using LPC2148 controller
// Pin Connection : LCD dataline (D0 to D7) connected to Port-0 pins
of P0.16 to P0.23 respectively and
// Rs(Register Select) pin of LCD connected to P0.6 and
// En(Enable) pin of LCD connected to P0.7
// R/W pin of LCD always ground
// : Keyapd Connected to Port-1
// : row(R1,R2,R3,R4) - (P1.22,P1.23,P1.24,P1.25)
// : col(C1,C2,C3,C4) - (P1.18,P1.19,P1.20,P1.21)
//******************************************************************************
#include"prototype.h"
unsigned char number_1[11] = "8496809651", number_2[11] = "9964497104", buffer[50],temp[11], i, j,

key_value[5], key_correct[5] = "1234";
unsigned char msg[20];

unsigned int first = 0, gate = 0;
char keys[4][4] = {
{'A', '*', '5', '1'}, //1,2,3,4
{'B', '0', '6', '2'}, //5,6,7,8
{'C', '9', '7', '3'}, //9,10,11,12
{'D', '#', '8', '4'} //13,14,15,16
};
int main()
{
PINSEL0 = 0x00050000;
PINSEL1 = 0x15000000;
PINSEL2 = 0x00000000;
IODIR0 = 0x00FFFCE0;
IODIR1 |= 0x0FC00000; //P1.25 to P1.22 as Output
IODIR1 &= ~(0x003C0000); //P1.18 to P1.21 as Input
IOCLR0 = 0x00FFF000;
LCD_init();

LCD_cmd(0x80);
LCD_string("LCD Initialized ");
L1: LCD_cmd(0x01);
LCD_cmd(0x80);
LCD_string("Enter Key:");
for(i = 0 ; i < 16 ; i++)
{
key_value[i] = _getKey(); // c-4 to c-1 of kepad connected to P1.18 to P1.21 respectively and
R1 to R4 of keypad connected to P1.22 to P1.25 respectively
delay();delay();
LCD_cmd(0X8B);
LCD_data(key_value[i]);
delay_wait(50);
}
goto L1;
}
unsigned char _getKey(void)
{
while(1)
{
IOPIN1 &= ~0x03C00000;
IO1PIN |= (0x07<<22); //OP1 HIGH
if(((IOPIN1&0x003C0000)>>18) == 0x0E)
return(keys[3][0]);
else if(((IOPIN1&0x003C0000)>>18) == 0x0D)
return(keys[2][0]);
else if(((IOPIN1&0x003C0000)>>18) == 0x0B)
return(keys[1][0]);
else if(((IOPIN1&0x003C0000)>>18) == 0x07)
return(keys[0][0]);
IOPIN1 &= ~0x03C00000;
IO1PIN |= (0x0B<<22); //OP2 HIGH
if(((IOPIN1&0x003C0000)>>18) == 0x0E)
return(keys[3][1]);
return(keys[2][1]);
return(keys[1][1]);
else if(((IOPIN1&0x003C0000)>>18) == 0x07)

return(keys[0][1]);
IOPIN1 &= ~0x03C00000;

IO1PIN |= (0x0D<<22); //OP3 HIGH
if(((IOPIN1&0x003C0000)>>18) == 0x0E)
return(keys[3][2]);
return(keys[2][2]);
return(keys[1][2]);
else if(((IOPIN1&0x003C0000)>>18) == 0x07)
return(keys[0][2]);
IOPIN1 &= ~0x03C00000;
IO1PIN |= (0x0E<<22); //OP4 HIGH
if(((IOPIN1&0x003C0000)>>18) == 0x0E)
return(keys[3][3]);
return(keys[2][3]);
return(keys[1][3]);
else if(((IOPIN1&0x003C0000)>>18) == 0x07)
return(keys[0][3]);
}
}

15. Demonstrate the use of an external interrupt to toggle an LED On/Off.
//******************************************************************************
// FileName : LED Programming using Port-0
// Description :Using PORT-0 all port pins of are making HIGH with certain delay and all port pin made LOW.
//******************************************************************************
//************* MAIN PROGRAM *****************************//
#include<lpc214x.h> // Header file for LPC2148 controller

void delay(void); // Function Declaration
unsigned int a = 0x000000C0, j=0;
int main()
{
PINSEL0 = 0x00000000; // Using PINSEL0 making P0.0 to P0.15 as GPIO
PINSEL1 = 0x00000000; // Using PINSEL1 making P0.16 to P0.31 as GPIO
IODIR0 = 0xFFFFFFFF; // Using IODIR0 making P0.0 to P0.31 as output port
while(1)
{
for( j=0;j<=8;j++)
{
IOSET0 = a; // P0.0 to P0.31 as set to high
delay(); // Delay Function Cal
IOCLR0 = a; // P0.0 to P0.31 as set to low
a = (a >> 1);
}
a = 0x3;
for( j=0;j<=8;j++)
{
IOSET0 = a; // P0.0 to P0.31 as set to high
delay(); // Delay Function Cal
IOCLR0 = a; // P0.0 to P0.31 as set to low
a = (a << 1);
}
a = 0x000000C0;
}

//************* END of MAIN PROGRAM *****************************//

//************** Delay Program Function *********//
void delay(void) // Function Defination

{
unsigned int i,j; // Defining two varibles
for(i=0;i<1000;i++)
for(j=0;j<1000;j++);
}
//************** END of Delay Program Function *********//

16. Display the Hex digits 0 to F on a 7-segment LED interface, with an appropriate delay in
between
//******************************************************************************
// FileName : Seven Segment Display Programming using Port-1
// Description : Printing the numbers 0 to 9 in 7-segment Display using LPC2148 controller
// Pin Connection : P1.24 to P1.31 port pins are connected to Seven segment dispaly of ABCDEFGH
terminals respectively.
//******************************************************************************

//*************** Function Defination **************//
void delay(void)
{
unsigned int i,j;
for(j=0;j<1000;j++)
for(i=0;i<1000;i++);
}
//*************** END of Function Defination **************//
//*************** MAIN Program **************//
int main()
{
PINSEL2 = 0x00000000; // P1.0 to P1.31 as GPIO
IODIR1 = 0xFF << 18; // P1.16 tp P1.31 as ouput port
while(1)
{
IOSET1 = 0x3F << 18; // To display zero (0-display) (0x3F000000 - This value for common Anode)
delay();delay();delay();delay();
IOCLR1 = 0x3F << 18;;
IOSET1 = 0x06 << 18; // To display one (1-display) (0x06000000)

IOCLR1 = 0x06 << 18;
IOSET1 = 0x5B << 18; // To display two (2-display) (0x5B000000)

IOCLR1 = 0x5B << 18;

IOSET1 = 0x4F << 18; // To display Three (3-display) (0x4F000000)

IOCLR1 = 0x4F << 18;
IOSET1 = 0x99000000; // To display Four (4-display) (0x66000000)

IOCLR1 = 0x99000000;
IOSET1 = 0x6D << 18; // To display Five (5-display) (0x6D000000)

IOCLR1 = 0x6D << 18;
IOSET1 = 0x7D << 18; // To display Six (6-display) (0x7D000000)

IOCLR1 = 0x7D << 18;
IOSET1 = 0x07 << 18; // To display Seven (7-display) (0x07000000)

IOCLR1 = 0x07 << 18;
IOSET1 = 0x7F << 18; // To display Eight (8-display) (0x7F000000)

IOCLR1 = 0x7F << 18;
IOSET0 = 0x6F << 18; // To display nine (9-display) (0x6F000000)
IOSET0 = 0x6F <<18;
}
}

MES LABORATORY Manual 2020

Uploaded by

Copyright:

Available Formats

You might also like

MES LABORATORY Manual 2020

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

MES LABORATORY Manual 2020

Uploaded by

Copyright:

Available Formats

Microcontroller & Embedded Systems 18CSL48

 16-bit/32-bit ARM7TDMI-S microcontroller in a tiny LQFP64 package.

Dept. of Computer Science & Engineering , SJBIT Page 1

Fig 1:Components Details of Online Board

Dept. of Computer Science & Engineering , SJBIT Page 2

Fig 3: Architecture Diagram of LPC2148

Dept. of Computer Science & Engineering , SJBIT Page 3

Fig 4: Pin Diagram of LPC 2148

Dept. of Computer Science & Engineering , SJBIT Page 4

AREA ALP1, CODE, READONLY

2. Develop an Assembly Language Programs to test Arithmetic Operations.

3. Develop an Assembly Language Programs to test Reverse subtraction.

4. Develop an Assembly Language Programs to test logical operations.

AREA ALP6, CODE, READONLY

Dept. of Computer Science & Engineering , SJBIT Page 5

5. Develop an Assembly Language Programs to test Load and store instructions.

AREA ALP8, CODE, READONLY

6. Develop an Assembly Language Programs to test for carry flag c in CPSR.

AREA ALP9, CODE, READONLY

7. Develop an Assembly Language Programs to test MOVS and MOVCS instructions.

AREA ALP13, CODE, READONLY

8. Develop an Assembly Language Programs to test ADDCS instruction.

Dept. of Computer Science & Engineering , SJBIT Page 6

Conduct the following experiments by writing program using ARM7TDMI/LPC2148 using

;/* PROGRAM TO MULTIPLY TWO 16BIT NUMBERS */

AREA MULTIPLY, CODE, READONLY

ENTRY ;Mark first instruction to execute

MOV r1, #6400 ; STORE FIRST NUMBER IN R0

END ;Mark end of file

Dept. of Computer Science & Engineering , SJBIT Page 7

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

AREA SUM10, CODE, READONLY

MOV R0, #10

Dept. of Computer Science & Engineering , SJBIT Page 8

AREA FACTORIAL, CODE, READONLY

Dept. of Computer Science & Engineering , SJBIT Page 9

AREA ADDITION, CODE, READONLY

LDR R4, =RESULT ; LOADS THE ADDRESS OF RESULT

AREA DATA2, DATA, READWRITE ; TO STORE RESULT IN GIVEN ADDRESS

RESULT DCD 0X0

Dept. of Computer Science & Engineering , SJBIT Page 10

AREA SQUARE, CODE, READONLY

MOV R2, #00

LOOKUP DCB 0,1,4,9,16,25,36,49,64,81,100

6 . a)Write a program to find the largest number in an array of 32 numbers.

AREA LARGEST , CODE, READONLY

6 b) Write a program to find the smallest number in an array of 32 numbers.

Dept. of Computer Science & Engineering , SJBIT Page 12

AREA SMALLEST , CODE, READONLY

RESULT DCD 0X0

7. A) Write a program to arrange a series of 32 bit numbers in ascending order.

;/* array of 4 numbers 0x44444444 ,0x11111111,0x33333333,0x22222222 */

AREA SORT, CODE, READONLY

OUTLOOP MOV R3, R1

INLOOP LDR R2, [R0], #4 ; WORD ALIGN T0 ARRAY ELEMENT

STR R2, [R0], #-4 ; INTERCHANGE NUMBER R2 & R0

SKIP SUBS R3, R3, #1 ; DECREMENT COUNTER

b) Write a program to arrange a series of 32 bit numbers in descending order.

//* Function Declaration //

//* END ofFunction Declaration //

//* END of MAIN Program //

//* END of Delay Program //

//* END of LCD initilization Program //

//* END of LCD Command Program //

//* END of LCD DATA Program //

//* END of LCD string Program //

//* END of MAIN Program //

//* END of Delay Program //

//* END of DC motor Program //

//* END ofFunction Declaration //

//* END of MAIN Program //

//* END of Delay Program //

// END of LCD data Program *//

// END of LCD string Program *//

//* END of MAIN PROGRAM *****************//

//****** END of Delay Program Function *//