Summary: Microcontroller, 8051
The 8051 Architecture
The 8051 architecture consists of the following features.
- Eight bit CPU with registers A(the accumulator) and B.
- Sisteen bit program counter (PC) and Data pointer (DPTR)
- Eight bit Program status word (PSW)
- Eight bit Stack Pointer (SP)
- Internal ROM or EPROM (8751) of 0(8031) to 4kbytes(8051)
- Internal RAM of 128 bytes:
- Four register banks each containing 8 registers.
- Sixteen bytes, bit addressable.
- Eighty bytes of general purpose Data memory.
- Thirty two I/O pins arranged as four 8-bit ports:P0-P3.
- Two 16-bit Timer/counters: T0 & T1.
- Full Duplex serial data receiver/transmitter :SBUF.
- Control registers :TCON, TMOD, SCON, PCON, IP, IE.
- Two external and three internal interrupt sources.
- Oscillator and clock circuits.
Table 1: Register Addresses and functions
Register | Address | Function |
P0 | 80h* | Port0 |
SP | 81h | Stack pointer |
DPL | 82h | Data pointer(low) |
DPH | 83h | Data Pointer(high) |
TCON | 88h* | Timer Control Register |
TMOD | 89h | Timer Mode Register |
TL0 | 8Ah | Timer 0 (low byte) |
TL1 | 8Bh | Timer 1 (low byte) |
TH0 | 8Ch | Timer 0 (high byte) |
TH1 | 8Dh | Timer 1 (high byte) |
P1 | 90h* | Port 1 |
SCON | 98h* | Serial control Register |
SBUF | 99h | Serial Buffer Register |
P2 | 0A0h* | Port 2 |
IE | 0A8h* | Interrupt Enable Register |
P3 | 0B0h* | Port 3 |
IP | 0B8h* | Interrupt Priority Register |
PSW | 0D0h* | Program Status Word |
ACC | 0E0h* | Accumulator |
B | 0F0h* |
- - Bit Addressable
Table 3: Byte & Bit Addresses for 8051 Hardware Register
Byte Address | B I T a d d r e s s | Register | |||||||
F0h | F7 | F6 | F5 | F4 | F3 | F2 | F1 | F0 | B |
E0h | E7 | E6 | E5 | E4 | E3 | E2 | E1 | E0 | ACC |
D0h | D7 | D6 | D5 | D4 | D3 | D2 | D1 | D0 | PSW |
B8h | -- | -- | -- | BC | BB | BA | B9 | B8 | IP |
B0h | B7 | B6 | B5 | B4 | B3 | B2 | B1 | B0 | P3 |
A8h | AF | -- | -- | AC | AB | AA | A9 | A8 | IE |
A0h | A7 | A6 | A5 | A4 | A3 | A2 | A1 | A0 | P2 |
98h | 9F | 9E | 9D | 9C | 9B | 9A | 99 | 98 | SCON |
90h | 97 | 96 | 95 | 94 | 93 | 92 | 91 | 90 | P1 |
88h | 8F | 8E | 8D | 8C | 8B | 8A | 89 | 88 | TCON |
80h | 87 | 86 | 85 | 84 | 83 | 82 | 81 | 80 | P0 |
Table 4
EA | --- | ET2 | ES | ET1 | EX1 | ET0 | EX0 |
Bit | Symbol | Function | |||||
7 | EA | Interrupt Enable bit | |||||
6 | -- | Not implemented | |||||
5 | ET2 | Reserved for future use | |||||
4 | ES | Enable serial port interrupt | |||||
3 | ET1 | Enable timer1 overflow interrupt | |||||
2 | EX1 | Enable external | |||||
1 | ET0 | Enable Timer 0 overflow interrupt | |||||
0 | EX0 | Enable External interrupt 0 |
1.Program to add two multibyte numbers.
mov r4,#0h ;move 00 to r4
mov r3,#0h ;move 00 to r3
mov dptr,#9000h ; Load 9000h into dptr register
movx a,@dptr ;move the data from memory location to a register
mov r0,a ;move the data from a to r0
inc dptr ;increment dptr
movx a,@dptr ;move the data from memory location to a
mov r1,a ;move the data from a register to r1
inc dptr ;increment dptr
movx a,@dptr ;move the data from memory to a
mov r2,a ;move the data form a to r2
inc dptr ;increment dptr
movx a,@dptr ; move the data from memory location to a register
clr c ;clear carry bit
add a,r1 ;add a and r1
jnc res ;if no carry, jump to label res
mov r3,a ;move data from a to r3
mov a,r0 ;move data from r0 to a
addc a,r2 ; add with carry and r2
jnc end1 ;if no carry, jump to label end1
inc r4 ;increment r4
ajmp end1 ;jump to label end1
res:mov r3,a ; move data from a to r3
mov a,r0 ; move data from r0 to a
add a,r2 ;add a and r2
jnc end1 ; if no carry, jump to label end1
inc r4 ;increment r4
end1:mov r5,a ;move data from a to r5
mov dptr,#900ah ;load 9000h into dptr register
mov a,r4 ; move data from r4 to a
movx @dptr,a ;move data from a to memory location
mov a,r5 ;move data from r5 to a
inc dptr ;increment dptr
movx @dptr,a ; move data from a to memory location
mov a,r3 ; move data from r3 to a
inc dptr ; increment dptr
movx @dptr,a ; move data from a to memory location
here:sjmp here
end
Input Location:9000h,9001h,9002h,9003h
Output Location:900ah
Input Data: 1111 1111(hex)
Output : 2222h
2 nd method
mov r1,#0ffh ;load r1 with immediate data
mov r2,#0ffh ; load r1 with immediate data
mov r3,#0ffh ;load r1 with immediate data
mov r4,#0ffh ;load r1 with immediate data
clr c ;Clear carry bit
mov a,r1 ;move data from r1 to a
add a,r4 ;add a and r4
mov 31h,a ;move data from a to internal RAM location 31h
mov a,r2 ;move data from r2 to a
addc a,r3 ;add with carry a and r3
mov 32h,a ; move data from a to internal RAM location 32h
mov a,#00 ;Clear a register
addc a,#00 ;add with carry and 0
mov 33h,a ; move data from a to internal RAM location 33h
here:sjmp here
end
2. Program to convert a BCD number to ASCII
To convert packed BCD to ASCII, it must first be converted to to unpacked BCD. Then the unpacked BCD is tagged with 30h.
mov dptr,#9000h ;Load 9000h into dptr register
movx a,@dptr ;Move the content of location 9000h to a
mov r2,a ;Move the data from a to r2
anl a,#0f0h ;And a with 0f0h
swap a ;Swap a
orl a,#30h ;Or a with 30h
inc dptr ;increment dptr
movx @dptr,a ;move the data from a to memory location
mov a,r2 ; Move the data from r2 to a
anl a,#0fh ; And a with 0fh
orl a,#30h ;Or a with 30h
inc dptr ;increment dptr
movx @dptr,a ;move the data from a to memory location
here:sjmp here
end
Input: 45
Output:34 35
3;ASCII to BCD conversion
To convert ASCII to packed BCD, it is first converted to unpacked BCD(to mask 3) and
then combined to make packed BCD. For example, for 4 and 5 the keyboard gives 34 and
35, respectively. The goal is to produce 45h, which is packed BCD.
;ASCII to packed BCD conversion
mov r0,#10h ;R0=10h,Internal memory adress
mov a,@r0 ;a=hex value of Ist ASCII number
anl a,#0fh ;mask upper nibble
swap a ;swap upper and lower nibble of a
mov b,a ;save the number in B
inc r0 ;Increment R0
mov a,@r0 ;Get the next number from memory
anl a,#0fh ;Mask Higher nibble
orl a,b ;Or a & B
inc r0 ;Increment memory address to store the result
mov @r0,a ;Move the content of A to internal RAM location
here:sjmp here
end
Input:35
Output:
4. Program to find the average of 10 numbers
mov dptr,#9000h ;Load 9000h into dptr register
clr a ;Clear a register
mov 0f0h,a ;move data from a to b
mov r1,#05h ;move 05 to r1 register
up: movx a,@dptr ; ;move data from external memory location to a
add a,0f0h ;add a and b
mov 0f0h,a ;move the result to b
dec r1 ;decrement r1
inc dptr ;increment dptr
cjne r1,#00h,up ;compare r1 with 0, if not equal, jump to label up
mov a,0f0h ;move data from b to a
mov 0f0h,#05h ;move 05h to b
div ab ;divide a by b
mov dptr,#09005h ; Load 9005h into dptr register
movx @dptr,a ;move data from a to external memory location
mov a,0f0h ;move data from b to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
5. To transfer a block of data from one memory location to another.
mov r2,#0ah ;Load r2 with immediate data 05h
mov dptr,#9000h ;Load 9000h into dptr register
mov r0,#0a0h ;Load r0 with immediate data 0a0h
mov r1,#00h ;Load r1 with immediate data 00h
mov a,#0h ; Load a with immediate data 00h
up:movx a,@dptr ;move data from external memory to a
push dph ;push dph on the stack
push dpl ;push dpl on the stack
mov dph,r0 ;move data from r0 to dph
mov dpl,r1 ;move data from r1 t dpl
movx @dptr,a ;move data from a to external memory location
pop dpl ;pop dpl from the stack
pop dph ;pop dph from the stack
inc dptr ;increment dptr
inc r1 ;increment r1
dec r2 ;decrement r2
cjne r2,#00,up ;compare r2 with 0, if not equal, jump to label up
here:sjmp here
end
Output:
I block:9000h: 01 02 03 04 05
II block:a000h:01 02 03 04 05( after block transfer)
6. Program to convert a decimal number to hex number
mov dptr,#9000h ; Load 9000h into dptr register
movx a,@dptr ; move data from external memory location to a
mov r2,a ;move data from r2 to a
clr c ;clear carry bit
subb a,#0ah ;subtract with borrow, 0ah from a
jc over ;if carry, jump to label over
mov a,r2 ;move data from r2 to a
anl a,#0f0h ;and a with 0f0h
swap a ;swap a
mov b,#0ah ;move 0ah to b
mul ab ;multiply and b
mov r3,a ;move data from a to r3
mov a,r2 ;move data from r2 to a
anl a,#0fh ;move 0fh to a
add a,r3 ;add a and r3
inc dptr ;increment dptr
movx @dptr,a ; move data from a to external memory location
sjmp here
over:mov a,r2 ;move data from r2 to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
Input:99
Output:63
7. Program to generate Fibonacci series
mov r1,#0ah ;Load r1 with immediate data 0ah
mov dptr,#9000h ;load 9000h into dptr register
movx a,@dptr ; move data from external memory location to a
inc dptr ;increment dptr
mov r0,a ;move data from a to r0
movx a,@dptr ; move data from external memory location to a
back:mov r2,a ;move data from a to r2
add a,r0 ;add a and r0
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
mov r3,a ;move data from a to r3
mov a,r2 ; move data from r2 to a
mov r0,a ; move data from a to r0
mov a,r3 ; move data from r3 to a
djnz r1,back ;decrement r1, if not 0, jump to label back
here:sjmp here
end
Output:00 01 01 02 03 05 08 0bh, 15h, 22h
8.Program to find the GCF of two numbers
mov dptr,#9000h ;Load 9000h into dptr register
movx a,@dptr ; move data from external memory location to a
mov b,a ; move data from a to b
inc dptr ;increment dptr
movx a,@dptr ; move data from external memory location to a
back:mov r1,b ;move data from b to r1
div ab ;divide a by b
mov a,b ;move data from b to a
jz mess ;if a=0, jump to label mess
mov a,r1 ;move data from r1 to a
jmp back ;jump to label back
mess:mov dptr,#9005h ;Load dptr with immediate data 9005h
mov a,r1 ;move data from r1 to a
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
Input: 05 02
Output:01
9.Program to convert hex number to ASCII number
mov dptr,#9000h ; Load dptr with immediate data 9005h
movx a,@dptr ; Load dptr with immediate data 9005h
clr c ;clear carry bit
subb a,#0ah ;subtract with borrow, 0ah from
movx a,@dptr ; move data from external memory location to a
jc down ;if carry, jump to label down
add a,#07h ;add 07 to a
down:add a,#30h ;add 30h to a
inc dptr ;increment dptr
movx @dptr,a ; move data from a to external memory location
here:sjmp here
end
Input:45
Output:34 35
10. Program to convert an 8bit Hex number to decimal number
mov dptr,#9000h ;Load 9000h into dptr register
movx a,@dptr ;move data from external memory location to a
mov r2,a ;move data from a to r2
clr c ;clear carry bit
subb a,#0ah ;subtract with borrow, 0ah from a
jc over ;if carry, jump to label over
mov a,r2 ;move data from r2 to a
subb a,#064h ;subtract with borrow, 64h from a
jc d1 ; if carry, jump to label d1
mov a,r2 ;move data from r2 to a
mov b,#64h ;move immediate data 64h to b
div ab ;divide a by b
inc dptr ;increment dptr
movx @dptr,a ; move data from external memory location to a
mov a,b ;move data from b to a
mov r3,a ;move data from a to r3
clr c ; clear carry bit
subb a,#0ah ;subtract with borrow, 0ah from a
jc d2 ;if carry, jump to label d2
mov b,#0ah ;Load b with immediate data 0ah
mov a,r3 ;move data from r3 to a
div ab ;divide a by b
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
mov a,b ;move data from b to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
sjmp end1
d2:mov a,r3 ;move data from r3 to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
sjmp end1
d1:mov a,r2 ;move data from r2 to a
mov b,#0ah ;load b with immediate data 0ah
div ab ;divide a by b
inc dptr ; increment dptr
movx @dptr,a ;move data from a to external memory location
mov a,b ;move data from b to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
sjmp end1
over:mov a,r2 ;move data from r2 to a
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end1:sjmp end1
end
Input: 0ffh
Output:02 05 05
11. Program to interchange two blocks of data
mov dptr,#9000h ;Load 9000h into dptr register
mov r0,#04h ;Move immediate data 04 to r0
mov r1,#90h ;move immediate data 90h to r1
mov r2,#91h ;move immediate data 91h to r2
back:movx a,@dptr ;move data from external memory location to a
mov r3,a ;move data from a to r3
mov dph,r2 ;move data from r2 to dph
movx a,@dptr ;move data from external memory location to a
mov dph,r1 ;move data from r1 to dph
movx @dptr,a ;move data from external memory location to a
mov a,r3 ;move data from r3 to a
mov dph,r2 ;move data from r2 to dph
movx @dptr,a ;move data from a to external memory location
inc dptr ;increment dptr
mov dph,r1 ;move data from r1 to dph
djnz r0,back ;decrement r0, if not equal to 0, jump to label back
here:sjmp here
end
12. Program to find the LCM of two numbers
mov dptr,#9000h ;Load dptr with immediate data 9000h
movx a,@dptr ;move data from external memory location to a
mov r0,a ;move data from a to r0
mov b,r0 ;move data from r0 to b
inc dptr ;increment dptr
movx a,@dptr ; move data from external memory location to a
mov r2,a ;move data from a to r2
l2:push 0e0h ;push a onto the stack
div ab ;divide a by b
mov r1,b ;move data from b to r1
cjne r1,#00,l1 ;compare r1 with 0, if not equal, jump to label l1
pop 0e0h ;pop a from satck
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
sjmp here
l1:pop 0e0h ;pop a from stack
add a,r2 ;add a and r2
mov b,r0 ;move data from r0 to b
sjmp l2
here:sjmp here
end
Input: 05 02
Output:0ah
13. Program to multiply 16 bit number by 8 bit number
mov r0,#11h ;load r0 with immediate data 11h
mov r1,#22h ;load r1 with immediate data 22h
mov r2,#33h ;load r2 with immediate data 33h
clr c ;clear carry bit
mov a,r0 ;move data from r0 to a
mov b,r2 ;move data from r2 to b
mul ab ;multiply and b
mov dptr,#9000h ;Load dptr with 9000h
movx @dptr,a ; move data from external memory location to a
mov r0,b ;move data from b to r0
mov a,r2 ;move data from r2 to a
mov b,r1 ;move data from r1 to b
mul ab ;multiply and b
add a,r0 ;add a and r0
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
inc dptr ;increment dptr
mov a,b ;move data from b to a
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
Input: 1122, 33
Output:369c6h
14. Program to search an element in an array
mov r0,#05h ;Load r0 with immediate data 05h
clr a ;clear a
mov dptr,#9000h ;load dptr with address 9000h
mov r1,#0ah ;load r1 with immediate data 0ah
l1:mov a,#0h ;load a with 00
movc a,@a+dptr ;move data from code memory location to a
mov r2,a ;move data from a to r2
inc dptr ;increment dptr
dec r1 ;decrement r1
cjne r2,#05h,l2 ;compare r2 with 05h, if not equal, jump to label l2
mov dptr,#900ah ;load dptr with immediate data 900ah
mov a,#0ffh ;laod a with immediate data 0ffh
movx @dptr,a ;move data from a to external memory location
sjmp here
l2:cjne r1,#0h,l1 ; compare r1 with 0, if not equal, jump to label l1
mov dptr,#900ah ;load dptr with 900ah
mov a,#0h ;load a with 00h
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
Input:05,
9000h: 01 02 03 04 05 06 07 08 09 0a
Output:0ff
15. Program to sort an array of 10 elements
mov r3,#0ah ;load r3 with immediate data 0ah
dec r3 ;decrement r3
start:mov a,r3 ;move data from r3 to a
mov r0,a ;move data from a to r0
mov dptr,#9000h ;Load dptr with address 9000h
l1:movx a,@dptr ;move data from external memory location to a
mov r1,a ;move data from a to r1
inc dptr ;increment dptr
movx a,@dptr ; move data from external memory location to a
clr c ;clear carry bit
subb a,r1 ;subtract with borrow, r1 from a
jnc next ;if no carry, jump to label next
movx a,@dptr ;move data from external memory location to a
mov r2,a ;move data from a to r2
mov a,r1 ;move data from r1 to a
movx @dptr,a ; move data from a to external memory location
dec dpl ;decrement dpl
mov a,r2 ;move data from r2 to a
movx @dptr,a ; move data from a to external memory location
inc dptr ;increment dptr
next:djnz r0,l1 ;decrement r0, if not equal to 0, jump to label next
djnz r3,start ;decrement r3, if not equal to 0, jump to label start
here:sjmp here
end
16. Program to divide an 8 bit no by another 8 bit number
mov r0,#26h ;load r0 with immediate data 26h
mov a,@r0 ;load a with data from internal RAM location(dividend)
inc r0 ;increment r0
mov b,@r0 ;move data from internal RAM location to b(divisor)
div ab ;divide a by b
inc r0 ;increment r0
mov @r0,a ;load internal RAM location with data from a
inc r0 ; increment r0
mov a,b ;move data from b to a
mov @r0,b ;move data from b to internal RAM location
here:sjmp here
end
17. Program to count number of 1's in a given data byte
mov dptr,#9000h ;Load dptr with 9000h
movx a,@dptr ;move data from external memory location to a
mov r0,#0h ;load r0 with 0
mov r1,#8h ;load r1 with 8
clr c ;clear carry bit
up:rlc a ;rotate a left through carry
jnc next ;if no carry, jump to label next
inc r0 ;increment r0
next:djnz r1,up ;decrement r1, and jump to label next, if r1≠0
inc dptr ;increment dptr
mov a,r0 ;move data from r0 to a
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
18. Program to find largest of n numbers
mov r0,#10h ;move immediate data 10h to r0.
mov a,@r0 ;move data from internal RAM location to a
mov r2,a ;move data from a to r2
dec r2 ;decrement r2
inc r0 ;increment r0
mov a,@r0 ;move data from internal RAM location to a
l2:push 0e0h ;save the content of a on stack
inc r0 ;increment r0
subb a,@r0 ;subtract content of internal RAM location from a
jnc down ;if no carry, jump to label down
mov a,@r0 ; move data from internal RAM location to a
sjmp d1 ;jump to location d1
down:pop 0e0h ;pop a from stack
d1:djnz r2,l2 ;decrement r2, if not zero, jump to location l2
inc r0 ;increment r0
mov @r0,a ;move data from a to internal RAM location
here:sjmp here
end
19. Program to convert ASCII to hex
ASCII codes 30 to 39 represent 0 to 9 in binary and 41 to 46 represent A to F. Therefore
if the ASCII code is between 30-39h then 30h is subtracted from the code. If the number
lies between A to F then 37h is subtracted from the code to get its binary equivalent
mov dptr, #9000h ;load dptr with address 9000h
movx a,@dptr ; move data from external memory location to a
clr c ;clear carry bit
mov r1,a ;move data from a to r1
subb a,#40h ;subtract 40h from a
jc l2 ;jump to location l2, if carry
mov a,r1 ;move data from r1 to a
subb a,#37h ;subtract with borrow, 37h from a
sjmp here ;jump to location here
l2:mov a,r1 ;move data from r1 to a
clr c ;clear carry bit
subb a,#30h ;subtract with borrow, 30h from a
here:inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
rep:sjmp rep
end
20. Program to check whether a 4th bit of a byte is 1, Store FFh if 1, else store 00 in
the same location
mov dptr,#9000h
movx a,@dptr ;move data from external memory location to a
jnb 0e3h,down ;jump to location down, if 4th bit of a is set
inc dptr ;increment dptr
mov a,#0ffh ;move 0ffh to a
movx @dptr,a ;move data from a to external memory location
sjmp last ;jump to location last
down:mov a,#0h ;move 00 to a
inc dptr ;increment dptr
movx @dptr,a ; move data from a to external memory location
last:sjmp last
end
21. Program to add two BCD numbers
mov dptr,#9000h ;move dptr with 9000h
movx a,@dptr ; move data from external memory location to a
mov b,a ;move data from a to b
inc dptr ;increment dptr
movx a,@dptr ; move data from external memory location to a
add a,b ;add a and b
da a ;decimal adjust accumulator after addition
jc down ;if carry, jump to label down
inc dptr ;increment dptr
movx @dptr,a ;move data from a to external memory location
sjmp last ;jump to label last
down:mov r2,a ;move data from a to r2
mov a,#01h ;move data 01h to a
movx @dptr,a ;move data from a to external memory location
inc dptr ;increment dptr
mov a,r2 ;move data from r2 to a
movx @dptr,a ;move data from external memory location to a
last:sjmp last
end
22.Program to find the square of an 8 bit number
mov dptr,#9000h ;load dptr with 9000h
movx a,@dptr ;move data from external memory location to a
mov b,a ;move data from a to b
mul ab ;multiply and b
inc dptr ;increment dptr
mov r0,a ;move data from a to r0
mov a,b ;move data from b to a
movx @dptr,a ;move data from a to external memory location
inc dptr ;increment dptr
mov a,r0 ;move data from r0 to a
movx @dptr,a ;move data from a to external memory location
here:sjmp here
end
23. Program to count from 0-9
here:mov a,#0h ;move 0 to a
up:mov p0,a ;move data from a to port0
acall delay ;call delay routine
add a,#01 ;increment a
cjne a,#010,up ;compare a with 10, if not equal, jump to location up
sjmp here ;jump to location here
;delay routine
delay:mov r1,#0ffh ;move 0ffh to r1
l3:mov r2,#0ffh ;move 0ffh to r2
l2:mov r3,#0ffh ;move 0ffh to r3
l1:djnz r1,l1 ;decrement r1, repeat till r1=0
djnz r3,l2 ;decrement r3,repeat l2 till r3=0
djnz r2,l3 ;decrement r2, repeat l3 till r2=0
ret ;return
end
24. Program to implement BCD counter to count from 0-99
here:mov a,#0h ;move 0 to a
up:mov p0,a ;move data fr
acall delay ;call delay program
inc a ;increment a
da a ;decimal adjust accumulator after addition
cjne a,#100,up ;compare a with 100, if not equal, jump to location up
sjmp here ;jump to location here
delay routine
delay:mov r1,#0ffh ;move 0ffh to r1
l3:mov r2,#0ffh ;move 0ffh to r2
l2:mov r3,#0ffh ;move 0ffh to r3
l1:djnz r1,l1 ;decrement r1, repeat till r1=0
djnz r3,l2 ;decrement r3,repeat l2 till r3=0
djnz r2,l3 ;decrement r2, repeat l3 till r2=0
ret ;return
end
25;Program to implement BCD counter to count from 99-0
here:mov b,#99h ;move 99h to b
up:mov a,b ;move data from b to a
add a,#99h ;add 99h to a
da a ;decimal adjust accumulator after addition
mov b,a ;move data from b to a
mov p0,a ;move data from a to p0
acall delay ;call delay routine
mov a,b ;move data from b to a
cjne a,#0ffh,up ;compare a with 0ffh, if not equal , jump to location up
sjmp here ;jump to location here
delay routine:
delay:mov r1,#25h ;move 25h to r1
l3:mov r2,#0ffh ;move 0ffh to r2
l2:mov r3,#0ffh ;move 0ffh to r3
l1:djnz r3,l1 ;decrement r3, jump if not equal to 0 to l1
djnz r2,l2 ;decrement r2, jump if not equal to 0 to l2
djnz r1,l3 ; decrement r1, jump if not equal to 0 to l3
ret
end
26. Program to generate 50msec delay
mov tmod,#01 ;select timer 0
here:mov tl0,#0fdh ;load tl0 with 0fdh
mov th0,#4bh ;load th0 with 4bh
cpl p1.5 ;compliment p1.5
acall delay ;call delay routine
sjmp here ;jump to here
delay:mov r1,#0c8h ;load r1 with data 0c8h
l1:setb tr0 ;set bit tr0
again:jnb tf0,again ;repeat till tf0=0
clr tr0 ;clear tr0
clr tf0 ;clear tf0
djnz r1,l1 ;decrement r1, jump to l1, if not equal to 0
ret
end
Part B: Interfacing programs
1.Write a C program to display the code of the key pressed
#include <REG51xD2.H>
#include "lcd.h"
unsigned char getkey();
void delay(unsigned int);
main()
{
unsigned char key;
InitLcd(); /* Initialise LCD */
WriteString("Key Pressed="); /* Display msg on LCD */
while(1)
{
GotoXY(12,0); /* Set Cursor Position */
key = getkey(); /* Call Getkey method */
}
}
unsigned char getkey()
{
unsigned char i,j,k,indx,t;
P0=0x0ff;
P1=0x0ff;
P2 = 0x00; /* P2 as Output port */
indx = 0x00; /* Index for storing the first value of
scanline */
for(i=0x00E;i>=0x00B;i<<=1) /* for 4 scanlines */
{
P2 = i; /* write data to scanline */
t = P0; /* Read readlines connected to P0*/
t = ~t;
if(t>0) /* If key press is true */
{
delay(6000); /* Delay for bouncing */
for(j=0;j<=7;j++) /* Check for 8 lines */
{
t >>=1;
if(t==0) /* if get pressed key*/
{
k = indx+j; /* Display that by converting to Ascii */
t = k>>4;
t +=0x30;
WriteChar(t); /* Write upper nibble */
t = k & 0x0f;
if(t > 9)
t+=0x37;
else
t+=0x30;
WriteChar(t); /* write lower nibble */
return(indx+j); /* Return index of the key pressed */
}
}
}
indx += 8; /* If no key pressed increment index */
}
}
void delay(unsigned int x) /* Delay routine */
{
for(;x>0;x--);
}
2.Elevator Interface
#include <REG51F.H>
void delay(unsigned int);
main()
{
unsigned char Flr[9] = {0xff,0x00,0x03,0xff,0x06,0xff,0xff,0xff,0x09};
unsigned char FClr[9] = {0xff,0x0E0,0x0D3,0xff,0x0B6,0xff,0xff,0xff,0x79};
unsigned char ReqFlr,CurFlr = 0x01,i,j;
P0 = 0x00;
P0 = 0x0f0;
while(1)
{
P1 = 0x0f;
ReqFlr = P1 | 0x0f0;
while(ReqFlr == 0x0ff)
ReqFlr = P1 | 0x0f0; /* Read Request Floor from P1 */
ReqFlr = ~ReqFlr;
if(CurFlr == ReqFlr) /* If Request floor is equal to Current Floor */
{
P0 = FClr[CurFlr]; /* Clear Floor Indicator */
continue; /* Go up to read again */
}
else if(CurFlr > ReqFlr) /* If Current floor is > request floor */
{
i = Flr[CurFlr] - Flr[ReqFlr]; /* Get the no of floors to travel */
j = Flr[CurFlr];
for(;i>0;i--) /* Move the indicator down */
{
P0 = 0x0f0|j;
j--;
delay(25000);
}
}
else /* If Current floor is < request floor */
{
i = Flr[ReqFlr] - Flr[CurFlr]; /* Get the no of floors to travel */
j = Flr[CurFlr];
for(;i>0;i--) /* Move the indicator Up */
{
P0 = 0x0f0 | j;
j++;
delay(25000);
}
}
CurFlr = ReqFlr; /* Update Current floor */
P0 = FClr[CurFlr]; /* Clear the indicator */
}
}
void delay(unsigned int x)
{
for(;x>0;x--);
}
3.Stepper motor interface
#include <REG51xD2.H>
static bit Dir=0;
void delay(unsigned int x) /* Delay Routine */
{
for(;x>0;x--);
}
void ChangeDir(void) interrupt 0 /* Int Vector at 000BH, Reg Bank 1 */
{
Dir = ~Dir; /* Complement the Direction flag */
ClrLcd();
if(Dir)
delay(32000);
else
delay(32000);
}
main()
{
unsigned char Val,i;
EA=0x1; /* Enable Interrupt flag and Interrupt 0 & Serial Interrupt */
EX0=0x1;
ES=0x1;
P0=0x00; /*since the monitor is using the serial interrupt it has to be enabled*/
while(1)
{
if(Dir) /* If Dir Clockwise */
{
Val = 0x88;
for(i=0;i<4;i++)
{
P0 = Val; /* Write data for clock wise direction*/
Val = Val>>1;
delay(575);
}
}
else /* AntiClockwise Direction */
{
Val = 0x11;
for(i=0;i<4;i++)
{
P0 = Val; /* Write data for anticlock wise direction*/
Val = Val<<1;
delay(575);
}
}
}
}
4. Seven segment display
#include<stdio.h>
#include <REG51.H>
void delay(int g);
int port[20] = {0xff,0xff,0xff,0xff,
0xc6,0x86,0xc7,0x86,
0xbf,0xc0,0xde,0x87,
0xbf,0x92,0x91,0x92,
0x92,0xc8,0x86,0x87},i;
void main(){
int d,b,j,k,s;
while(1){
i=0;
for(d=0;d<5;d++)
{
for(b=0;b<4;b++)
{
k=port[i++];
for(j=0;j<8;j++){
s=k;
s=s&0x80;
if(s==0x00)
P1= 0x00;
else
P1=0x1;
P2 = 0x1;
P2=0x00;
s=k;
s=s<<1;
k=s;
}
}
delay(10000);
delay(10000);
}
}
}
void delay(int g)
{
int h;
for(h=0;h<=g;g++)
{
;
}
}
6. Dual DAC, square wave
#include <REG51xD2.H>
#include "lcd.h"
sbit Amp = P3^3; /* Port line to change amplitude */
sbit Fre = P3^2; /* Port line to change frequency */
void delay(unsigned int x) /* delay routine */
{
for(;x>0;x--);
}
main()
{
unsigned char on = 0x7f,off=0x00;
unsigned int fre = 100;
InitLcd(); /* Initialize LCD */
WriteString("Squarewave"); /* Write to LCD */
while(1)
{
if(!Amp) /* if user choice is to change amplitude */
{
while(!Amp); /* wait for key release */
on+=0x08; /* Increase the amplitude */
}
if(!Fre) /* if user choice is to change frequency */
{
if(fre > 1000) /* if frequency exceeds 1000 reset to default */
fre = 100;
while(!Fre); /* wait for key release */
fre += 50; /* Increase the frequency */
}
P0=on; /* write amplitude to port */
P1=on;
delay(fre);
P0 = off; /* clear port */
P1 = off;
delay(fre);
}
}
7. Dual DAC, triangle wave
#include <REG51xD2.H>
#include "lcd.h"
main()
{
unsigned char i=0;
InitLcd(); /* Initialise LCD */
WriteString("Triangular Wave"); /* Display on LCD */
P0 = 0x00; /* P0 as Output port */
while(1)
{
for(i=0;i<0xff;i++){ /* Generate ON pulse */
P1 = i;
P0 = i; }
for(i=0xfe;i>0x00;i--) /* Generate OFF pulse */
{P0 = i;
P1 = i;}
}
}
8. Dual DAC, RAMP wave
#include <REG51xD2.H>
main()
{
unsigned char i=0;
P0 = 0x00; /* P0 as Output port */
while(1)
{
for(i=0;i<0xff;i++)
{
P1 = i;
P0 = i;
}
P0 = 0;
P1 =0;
}
}
Microcontroller Lab Question Bank
- Write an ALP to add, subtract, multiply and divide 2 8 bit numbers
- Write an ALP to transfer a block of data from one location to another location
- Write an ALP to exchange two blocks of data stored in memory.
- Write an ALP to add/subtract 2 16 bit numbers
- Write a program to add two BCD numbers
- Write a program to count the number of 1’s in a given data byte.
- Write a program to check whether the 4th bit of a byte is 0. Store FF if it 1.Else
store 00 in the same location
- Write an ALP to multiply a 16 bit number by an 8 bit number
- Write a programto find the average of 10 numbers
- Write an ALP to find the square of a given number
- Write an ALP to find the cube of a given number
- Write an ALP to arrange a set of data in ascending/descending order
- Write a program to find the GCF of two numbers
- Write a program to generate Fibonacci series.
- Write a program to find LCM of two numbers
- Write a program to search an element in an array of N numbers
- Write an ALP to find the largest of N numbers.
- Write an ALP to implement BCD counter to count from 0-9
- Write a program to implement BCD counter to count from 9-0
- Write a program to implement BCD counter to count from 99-00
- Write a program to implement BCD counter to count from 00-99
- Write a program to to convert a hexadecimal number to ASCII number
- Write a program to convert hexadecimal number to a decimal number.
- Write a program to convert an ASCII number to hexadecimal number
- Write a program to convert a BCD to ASCII number.
- Write a program to convert an ASCII number to BCD number
- Write a program to generate a delay of 50ms.
- Write a C program to interface Alphanumeric LCD panel and Hex keypad input to 8051
- Write a program to generate Square wave using DAC interface to 8051.
- Write a program to generate Triangular wave using DAC interface to 8051.
- Write a program to generate Ramp wave using DAC interface to 8051.
- Write a program to generate Sine wave using DAC interface to 8051.
- Write a C program to rotate Stepper motor in clockwise direction.
- Write a C program to rotate stepper motor in anticlockwise direction.
- Write a C program to interface Elevator to 8051.
- Write a C program to display a string on seven segment display interface
0 comments:
Post a Comment