Interfacing with seven segment display and LED

using ARM.

(a) Aim: To write and execute a program in Keil Software,interfacing ARM with
SevenSegment Display

Apparatus Required:

Keil Microvision4

Background Theory:

7 segment displays are among the simplest display units to display the numbers and
characters. It is generally used to display numbers and has brighter illumination and
simpler construction than dot matrix display. And because of brighter illumination,
the output can be viewed from larger distance than LCD. As shown in the above
image of a 7-segment display, it consists of 8 LEDs, each LED used to illuminate one
segment of unit and the 8thLED used to illuminate DOT in 7 segment display.
8thLED is used when two or more 7-segment modules are used, for example to
display (0.1). A single module is used to display single digit or character. To display
more than one digit or character, multiple 7-segments are used.
Depending upon connection we classify 7-Segment in two types:

Common Cathode

In this all the Negative terminals (cathode) of all the 8 LEDs are connected
together (see diagram below), named as COM. And all the positive terminals
are left alone or connected to the microcontroller pins. If we use
microcontroller we set logic HIGH to illuminate the particular and set LOW
to turn OFF LED.

Common Anode

In this all the positive terminals (Anodes) of all the 8 LEDs are connected
together, named as COM. And all the negative thermals are left alone or
connected to the microcontroller pins. If we use microcontroller we set logic
LOW to illuminate the particular and set logic High to turn OFF LED.

So depending upon the pin value, a particular segment or line of 7 segment

can be turned on or Off to display desired number or alphabet. For
example to display 0 digit we must set pins ABCDEF as HIGH and only G as
LOW. As ABCDEF LEDs are ON and G is OFF this forms the 0 digit in 7-
segment module. (This is for common cathode, for common anode it is
opposite).

Below table shows the HEX values and corresponding digit according to
LPC2148 pins for common cathode configuration.
The table below shows the circuit connections between 7-Segment module
& LPC2148
Program:

#include<lpc214x.h> //Header file for LPC214x Series microcontrollers

void delay(int ); //Function declaration for delay
int i; //Variable declared as integer
unsigned int a[]={0xf3,0x12,0x163,0x133,0x192,0x1b1,0x1f1,0x13,0x1f3,0x1b3};
//integer array with numbers for display
int main()
{
IO0DIR=IO0DIR|0xffffffff; //Sets direction as output for PORT 0 pins
while(1)
{
for(i=0;i<=9;i++)
{
IO0SET=IO0SET|a[i]; //sets corresponding pins HIGH
 delay(9000); //Calls delay function
IO0CLR=IO0CLR|a[i]; //Sets corresponding pins LOW
}
}
return 0;
}
void delay(int k) //Function for making delay
{
int i,j;
for(i=0;i<k;i++)
for(j=0;j<=1000;j++);
}

Result: Thus a program has been written and executed in Keil, interfacing ARM
withseven segment display.
(a) Aim: To write and execute a program in Keil Software,interfacing ARM 7 with
LED and make it blink.

Apparatus Required:

Keil Microvision4

Background Theory:

ARM (Advanced RISC Machines) originally known as Acorn RISC Machine is a

family of reduced instruction set computing (RISC) architecture for computer
processors, configured for various environments. Arm holdings is a British company
who developed this architecture and licensed it to other companies, who design their
own product by using this architecture.

ARM processor is widely found in electronics products such as LED TV, mobile
phones, tablets, multimedia devices, gaming devices etc. Even popular electronics
company like Apple’s mobiles and iPods, Raspberry pi 3 uses ARM architecture and
Arm processor in it. Arm Architecture Examples: ARM7, ARM9, ARM11,
CORTEX.

With more features ARM processor consumes less power.

ARM processor are cheap and that’s why widely used in consumer electronics
Performs one operation at a time and works faster.

Pin Details
Program:

#include <lpc214x.h> //include header files for LPC-214x series

void delay_ms(unsigned int count)

unsigned int j=0,i=0;

for(j=0;j<count;j++) //For loop to create delay

for(i=0;i<3000;i++);

int main()

IO0DIR = (1<<10); //Configure the pin P0.10 as OUTPUT;

while(1) // While loop to execute program continueously

IO0SET = (1<<10) ; // Make the pin P0.10 HIGH (LED ON)

delay_ms(1000);

IO0CLR = (1<<10); // Make the pin P0.10 LOW (LED OFF)

delay_ms(1000);

Result: Thus a program has been written and executed in Keil to interface ARM 7
with LED and make it blink.
Ex No: 2
ASSEMBLY LANGUAGE PROGRAMS USING 8051
Date:
AIM
To write an assembly language program to perform arithmetic operations using
8051 microcontroller.
APPARATUS REQUIRED
1. 8051 Microcontroller kit
2. Keyboard 2a. ADDITION

ALGORITHM
1. Start the program
2. Get the first operand in accumulator
3. Add second operand with first operand in accumulator
4. Move data from accumulator to data pointer
5. Store the result in memory
6. Stop the program

FLOWCHART

PROGRAM
ADDRESS LABEL OPERAND OPCODE COMMENTS
8500 MOV A,#34 74,34 Get 1st operand in A
register
8502 ADD A,#62 24,62 Add operand in A
register
8504 MOV DPTR,#8600 90,45,00 Initialize the data
pointer
8507 MOV X@DPTR,A F0 Store the result in
memory
8508 Here SJMP Here 80 ,FE Stop the program
Execution
INPUT OUTPUT

ADDRESS DATA ADDRESS DATA

2b. SUBTRACTION

ALGORITHM
1. Start the program
2. Get the first operand in accumulator
3. Subtract the second operand from first operand in accumulator
4. Move data from accumulator to data pointer
5. Store the result in memory
6. Stop the program

PROGRAM
ADDRESS LABEL OPERAND OPCODE COMMENTS
8500 MOV A,#62 74,34 Get 1st operand in A
register
8502 SUBB A,#34 24,62 Subtract operand in A
register
8504 MOV DPTR,#8600 90,45,00 Initialize the data
pointer
8507 MOV X@DPTR,A F0 Store the result in
memory
8508 Here SJMP Here 80 ,FE Stop the program
Execution
INPUT OUTPUT

ADDRESS DATA ADDRESS DATA

2c. MULTIPLICATION
ALGORITHM
1. Start the program
2. Get the multiplier in A register
3. Get the multiplicand in B register
4. Multiply accumulator content and B register content
5. Store the result in memory
6. Stop the program

FLOWCHART

PROGRAM
ADDRESS LABEL OPCODE OPERAND COMMENTS
8500 MOVA,#06 74,06 Get multiplier in A register

8502 MOV F0,#03 75,0F,03 Get multiplicand in B register

8505 MUL AB A4 Multiply A with B

8506 MOV 90 45 00 Store the result in 4500

DPTR,#8600
8509 MOV X@DPTR,A F0 Move the content to data
pointer
850A INC DPTR A3 Increment data pointer

850B MOVA,F0 E5,F0 Move the content of B register

to accumulator.
850D MOV X@DPTR,A F0 Move the content to data
pointer
850E Here SJMP Here 80,FE Stop the program
Execution
INPUT OUTPUT

ADDRESS DATA ADDRESS DATA

2d. DIVISION

ALGORITHM
1. Start the program
2. Get the multiplier in A register
3. Get the multiplicand in B register
4. Multiply accumulator content and B register content
5. Store the result in memory
6. Stop the program
PROGRAM
ADDRESS LABEL OPCODE OPERAND COMMENTS
8500 MOV A,#06 74,06 Get Divisor in A register

8502 MOV F0,#03 75,0F,03 Get Dividend in B register

8505 DIV AB A4 Divide A and B

8506 MOV DPTR,#8600 90 45 00 Store the result in 4500

8509 MOV X@DPTR,A F0 Move the content to data

pointer
850A INC DPTR A3 Increment data pointer

850B MOV A,F0 E5,F0 Move the content of B reg. to

A reg.
850D MOV X@DPTR,A F0 Move the content to data
pointer
850E Here SJMP Here 80,FE Stop the program
Execution
INPUT OUTPUT

ADDRESS DATA ADDRESS DATA

2e) BIT OPERATIONS BY USING 8051

BIT OPERATIONS

SET A BIT

MOV DPTR, #STARTING ADDRESS

MOVX A, @DPTR
SETB 0E5
INC DPTR
MOVX @DPTR, A
L4: SJMP L4 (OFFSET ADDRESS)
LCALL 03

RESET A BIT

MOV DPTR, #STARTING ADDRESS

MOVX A, @DPTR
CLR 0E5
INC DPTR
MOVX @DPTR, A
L4: SJMP L4 (OFFSET ADDRESS)
LCALL 03

COMPLIMENT A BIT
MOV DPTR, #STARTING ADDRESS
MOVX A, @DPTR
CPL 0E5
INC DPTR
MOVX @DPTR, A
L4: SJMP L4 (OFFSET ADDRESS)
LCALL 03

RESULT
Thus the demonstration of basic instructions including conditional jumps,
looping, calling subroutines, stack parameter testing was executed using 8051
microcontroller.
 Experiment No. 4 Interfacing DAC and ADC with 8051

Aim:
(a) To execute an Assembly Language Program to convert digital input to analog
output by interfacing Digital to Analog Converter with 8051.

Apparatus Required:

8051 Micro controller Kit

DAC board
Interfacing Chord

Algorithm
1. Initialize the accumulator with 0x80.
2. Set DPTR to 0x4003.
3. Move the value in the accumulator to the memory location pointed by DPTR (0x4003).
Main Loop START:
4. Set the accumulator with 0x00.
5. Set DPTR to 0x4000.
6. Move the value in the accumulator to the memory location pointed by DPTR (0x4000).
7. Call DELAY subroutine.
8. Set the accumulator with 0xFF.
9. Set DPTR to 0x4000.
10. Move the value in the accumulator to the memory location pointed by DPTR
(0x4000).
11. Call DELAY subroutine.
12. Jump to START to repeat the loop.
Delay Subroutine DELAY:
a. Load R1 with 0x10.
Outer Loop LOOP1:
i. Load R0 with 0xFF.
 Inner Loop LOOP2:
- Decrement R0.
- If R0 is not zero, jump back to LOOP2.
ii. Decrement R1.
iii. If R1 is not zero, jump back to LOOP1.
b. Return from the subroutine.
Program:

ADDRESS OPCODE MNEMONICS

9100 74 80 MOV A,#80H
9102 90 40 03 MOV DPTR,#4003
9105 F0 MOVX @DPTR,A
9106 74 00 START: MOV A,#00H
9108 90 40 00 MOV DPTR,#4000
910B F0 MOVX @DPTR,A
910C 12 91 1A LCALL DELAY
910F 74 FF MOV A,#0FFH
9111 90 40 00 MOV DPTR,#4000
9114 F0 MOVX @DPTR,A
9115 12 91 1A LCALL DELAY
9118 80 EC SJMP START
911A 79 10 DELAY: MOV R1,#10H
911C 78 FF LOOP1: MOV R0,#0FFH
911E 18 LOOP2: DEC R0
911F B8 00 FC CJNE RO,#00H,LOOP2
9122 19 DEC R1
9123 B9 00 F6 CJNE R1,#00H,LOOP1
9126 22 RET
INFERENCE OF THE RESULT:

Result:
Thus the assembly language program was written to convert digital input to
analog output by interfacing Digital to Analog Converter with 8051.
 Aim:

(b) To execute an Assembly Language Program to convert analog input to

digital output by interfacing Analog to Digital Converter with 8051.

Apparatus Required:

8051 Micro controller Kit

ADC board
Interfacing Chord

Algorithm:

1. Initialize A with 0x90.

2. Set DPTR to 0x4003.
3. Write A (0x90) to the external memory at DPTR (0x4003).
4. Set DPTR to 0x4001.
5. Initialize A with 0x01.
6. Write A (0x01) to the external memory at DPTR (0x4001).
7. Initialize A with 0x31.
8. BACK: Write A (0x31) to the external memory at DPTR (0x4001).
9. AND A with 0x01.
10. If the 0th bit of A is not set, jump to BACK.
11. Initialize A with 0x40.
12. Write A (0x40) to the external memory at DPTR (0x4001).
13. Call DELAY subroutine.
14. Set DPTR to 0x4000.
15. Move the value from external memory at DPTR (0x4000) to A.
16. Call the subroutine at address 0x00BB.

DELAY Subroutine:
17. Initialize R0 with 0xFF.
18. LOP: Initialize R1 with 0xFF.
19. LOP1: Decrement R1. If R1 is not zero, jump to LOP1.
20. Decrement R0. If R0 is not zero, jump to LOP.
21. Return from the subroutine.

Program:

ADDRESS OPCODE MNEMONICS

9100 74 90 MOV A,#90
9102 90 40 03 MOV DPTR,#4003
9105 F0 MOVX @DPTR,A
9106 90 40 01 MOV DPTR,#4001
9109 74 01 MOV A,#01
910B F0 MOVX @DPTR,A
910C 74 31 MOV A,#01
910E F0 BACK : MOVX @DPTR,A
910F 74 01 ANL A,#01
9111 F0 JNB 0A,BACK
9112 54 01 MOV A,#40
9114 30 OA FA MOVX @DPTR,A
9117 74 40 LCALL DELAY
9119 F0 MOV DPTR,#4000
911A 12 91 24 MOVX A,@DPTR
911D 90 40 00 LCALL 00BB
9120 E0 DELAY : MOV R0,#FF
9121 12 00 BB LOP: MOV R1,#FF
9124 78 FF LOP1: DJNZ R1,LOP1
9126 79 FF DJNZ RO,LOP
9128 D9 FE RET
912A D8 FA
912C 22

INFERENCE OF THE RESULT:

 Result:
Thus the assembly language program was written to convert analog input to digital
output by interfacing Analog to Digital Converter with 8051.
 Experiment No.3. Stepper motor control using 8051.

Aim:
To run a stepper motor at different speed in forward and reverse directions.

Apparatus Required:

8051 Micro controller Kit

Stepper motor interfacing kit

Algorithm
1.Start the program
2.Initialize the counter and DPTR
3.Get the value of micro controller
4.Execute till the rotation of stepper motor
5.Stop the program
Program:

Memory
Mnemonics
Address
8500 MOV A,#80

8502 MOV DPTR,#4003

8505 MOVX @DPTR,A

8506 START: MOV DPTR,#8600

8509 MOV R1,82

850B MOV R2,83

850D MOV R0,#04

850F REP: MOVX A,@DPTR

8510 MOV DPTR,#4000

8513 MOVX @DPTR,A

 8514 LCALL DELY

8517 INC R1

8518 MOV 82,R1

851A MOV 83,R2

851C DJNZ R0,REP

851E SJMP START

8520 DELY: MOV R7,#03

8522 LOOP3: MOVR6,#0A

8524 LOOP2: MOV R3,#FF

8526 LOOP1: DJNZ R3,LOOP1

8528 DJNZ R6,LOOP2

852A DJNZ R7,LOOP3

852C RET

INFERENCE OF THE RESULT:

Result:
Thus the assembly language program was written to rotate a stepper motor
in forward and reverse directions and executed by using 8051 microcontroller &
stepper motor interfacing kit.
Ex No: 1
ASSEMBLY LANGUAGE PROGRAMS USING 8086

AIM
To write the assembly language program to perform arithmetic operation using
8086 microprocessor

APPARATUS REQUIRED
 8086 microprocessor Kit
 Keyboard

1 a) ADDITION OF TWO 32-BIT NUMBERS USING

8086 ALGORITHM
Addition
1. Start the program
2. Load the LSB and MSB of 1st number to AX and BX register respectively
3. Load the LSB and MSB of 2nd number to CX and DX register respectively
4. Initialize the carry as zero
5. Add the LSB of both the numbers
6. Add the MSB of both the numbers with previous carry
7. Check the carry flag, if set then increment carry by 1
8. Store the sum in memory location
9. Halt the program.

FLOW CHART
 PROGRAM

ADDRESS LABEL MNEMONICS COMMENTS

1000 MOV AX,[2000] Move LSB of 1st number to AX register.
1003 MOV BX,[2002] Move MSB of 1st number to BX register.
1007 MOV CX,[2004] Move LSB of 2nd number to CX register.
100B MOV DX,[2006] Move MSB of 2nd number to DX register.
100F MOVDI,0000 Initialize Carry to zero
1012 ADD AX,CX Add the LSB of both the numbers
1014 ADC BX,DX Add the MSB of both the numbers with previous carry
1016 JNC 101B If Carry=0, go to LOOP
1018 MOVDI,0001 Increment Carry by 1
101B LOOP MOV[2008],AX Store the LSB of sum.
101E MOV[200A],BX Store the MSB of sum.
1022 MOV[200C],DI
1026 HLT Stop the program.

EXECUTION

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
Ex.No:1b SUBTRACTION OF TWO 32-BIT NUMBERS USING
8086

ALGORITHM
Subtraction
1. Start the program
2. Load the LSB and MSB of 1st number to AX and BX register respectively
3. Load the LSB and MSB of 2nd number to CX and DX register respectively
4. Initialize the carry as zero
5. Subtract the LSB of both the numbers
6. Subtract the MSB of both the numbers with previous borrow
7. Store the sum in memory location
8. Halt the program.

FLOWCHART

PROGRAM

ADDRESS MNEMONICS COMMENTS

1000 MOV AX,[2100] Move LSB of 1st number to AX register.
1003 MOV BX,[2102] Move MSB of 1st number to BX register.
1007 MOV CX,[2104] Move LSB of 2nd number to CX register.
100B MOV DX,[2106] Move MSB of 2nd number to DX register.
100F SUB AX,CX Subtract the LSB of both the numbers
Subtract the MSB of both numbers with previous
1011 SBB BX,DX
borrow
1013 MOV[2108],AX Store the LSB of result.
 1016 MOV[210A],BX Store the MSB of result.
101A HLT Stop the program.

EXECUTION

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
 Ex.No:1c MULTIPLICATION OF TWO 16-BIT NUMBERS
USING 8086

ALGORITHM
Multiplication

1. Start the program

2. Move the 1st 16-bit data to AX register
3. Move the 2nd 16- bit data to BX register
4. Multiply both the numbers
5. Store the result from the Accumulator to the specified address
6. Move the carry from DX register to the specified address
7. Stop the program

FLOWCHART

PROGRAM

ADDRESS MNEMONICS COMMENTS

2000 MOV AX,[1100] Move the 1st data from the address to AX register.
2003 MOV BX,[1102] Move the 2nd data from the address to BX register.
Multiply the contents of BX register with the
2007 MUL BX
Accumulator i.e., AX register.
Move the result from Accumulator register to the
2009 MOV [1200],AX
address
200C MOV [1202],DX Move the Carry from DX register to the address
2010 HLT Stop the program.
EXECUTION

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA
Ex.No:1d DIVISION OF TWO 16-BIT NUMBERS
USING 8086

Division
ALGORITHM

1. Start the program

2. Initialize DX register for storing the reminder
3. Move the 1st 16-bit data i.e dividend to AX register
4. Move the 2nd 16-bit data i.e divisor to BX register
5. Divide both the numbers.
6. Store the result from the accumulator to the specified address.
7. Move the remainder from DX register to the specified address.
8. Stop the Program

FLOWCHART
PROGRAM

ADDRESS MNEMONICS COMMENTS

2000 MOV DX,[1100] Initialize the DX register for storing the remainder.
2004 MOV AX,[1102] Move the dividend from the address to AX register.
2007 MOV BX,[1104] Move the divisor from the address to BX register.
Divide the contents of BX register with the
200B DIV BX
Accumulator i.e., AX register.
Move the quotient from Accumulator register to the
200D MOV [1200],AX
address
2010 MOV [1202],DX Move the remainder from DX register to the address
2014 HLT Stop the program.

EXECUTION

INPUT OUTPUT
ADDRESS DATA ADDRESS DATA

RESULT

Thus the arithmetic operations are performed using 8086 microprocessor and
the result is stored in memory.
 Ex No.5 Sensor Interfacing using 8051 Micro controller

Objective: To measure the temperature and store the digital value in memory using 8051 microcontroller.

Apparatus:

● 8051 kit
● ADC board
● LM35 (temperature sensor)

Theory:

The LM35 series sensors are precision integrated-circuit temperature sensors, whose output voltage is
linearly proportional to the Centigrade temperature. It gives 10mV of output voltage for every 10C. The LM35
does not require any external calibration or trimming to provide typical accuracies of ±¼°C at room temperature
and ±¾°C over a full -55 to +150°C temperature range. The LM35's low output impedance, linear output, and
precise inherent make interfacing to readout or control circuitry especially easy. It can be used with single
power supplies, or with dual supplies. As it draws only 60 µA from its supply, it has very low self- heating, less
than 0.1°C in still air. The LM35 is rated to operate over a -55° to +150°C temperature range. The LM35 IC
sensor is available at a Low cost .LM35 is a three terminal IC with, Vcc, Ground & Vout

The LM 35 IC gives a 10mV analog output voltage for every degree Celsius change in temperature. The
Output of the temperature sensor is analog in nature so we need an analog to digital converter for converting
the analog input to its equivalent binary output.
Since the output of LM35 is analog voltage, it should be converted into digital before it is applied to a
microcontroller port pin.
Circuit:

Program:

MOV P1, #0xFF ; Configure Port 1 as input (data lines from ADC)
MOV P2, #0x00 ; Configure Port 2 as output (control signals to ADC)

START:

CLR P2.3 ; Set WR (P2.3) low to start conversion

NOP ; Small delay
SETB P2.3 ; Set WR (P2.3) high after starting conversion

WAIT_INTR:
JB P2.4, WAIT_INTR; Wait until INTR (P2.4) goes low
; Read ADC data
CLR P2.1 ; Set CS (P2.1) low to enable ADC
CLR P2.2 ; Set RD (P2.2) low to read data
MOV A, P1 ; Read data from ADC to accumulator
MOV TEMP_LOW, A; Store low byte of temperature reading
SETB P2.2 ; Set RD (P2.2) high after reading data
MOV A, TEMP_LOW
ADD A, A
MOV TEMP_HIGH, A; Store high byte of temperature (in °C)
SJMP START ; Repeat the process
END
Result:
Thus, the temperature is measured and stored in memory using 8051.