; SIMPLE MULTITASKING PROGRAM
$MOD51
$NOPRINT
$INCLUDE(MYPAULM2.EQU)
LED equ P1.7
CR EQU 13
DSEG AT 20H
DS 1
FLAG1:
TICK:
SEC:
MIN:
HOUR:
TIMER1:
TIMER2:
TIMER3:
TIMER4:
COMMAND:
DS
DS
DS
DS
DS
DS
DS
DS
DS
1
1
1
1
1
1
1
1
1
CSEG AT 8000H
jmp main
ORG 8100H
; 10ms tick
; ____|____|____|____|____
;
WAIT_TICK:
JNB TF0,$
CLR TF0
ORL TH0,#0DCH
INC TICK
RET
UPDATE_CLOCK:
MOV A,TICK
CJNE A,#100,EXIT_CLOCK
MOV TICK,#0
SETB FLAG1.0
SETB FLAG1.1
; flag that signals print time function
; for tick led
MOV A,SEC
ADD A,#1
DA A
MOV SEC,A
CJNE A,#60H,EXIT_CLOCK
MOV SEC,#0
MOV A,MIN
ADD A,#1
DA A
MOV MIN,A
CJNE A,#60H,EXIT_CLOCK
MOV MIN,#0
MOV A,HOUR
ADD A,#1
DA A
MOV HOUR,A
CJNE A,#24H,EXIT_CLOCK
MOV HOUR,#0
EXIT_CLOCK:
RET
; MAKE LED ON EVERY ONE SECOND
; ------______------------------------------______----------------;
|50ms|
;
|-------------------- 1000ms -------|
;
TICK_LED:
JNB FLAG1.1,EXIT1
CLR LED
INC TIMER1
MOV A,TIMER1
CJNE A,#5,EXIT1
SETB LED
CLR FLAG1.1
MOV TIMER1,#0
EXIT1:
RET
; check serial port every 10ms
; exit: COMMAND == -1 NO CHARACTER
;
COMMAND != -1 ASCII CODE
GETCHAR:
JNB
CLR
MOV
MOV
RET
EXIT2:
RI,EXIT2
RI
A,SBUF
COMMAND,A
MOV COMMAND,#-1
RET
; PRINT TIME TO TERMINAL EVERY SECOND
PRINT_TIME:
JNB FLAG1.0,EXIT_PRINT_TIME
CLR FLAG1.0
PRINT_TIME1:
MOV A,#CR
CALL COUT
MOV A,HOUR
CALL PHEX
MOV A,#':'
CALL COUT
MOV A,MIN
CALL PHEX
MOV A,#':'
CALL COUT
MOV A,SEC
CALL PHEX
EXIT_PRINT_TIME:
RET
HOUR_KEY:
MOV A,COMMAND
CJNE A,#'h',EXIT_HOUR_KEY
MOV A,HOUR
ADD A,#1
DA A
MOV HOUR,A
CJNE A,#24H,SKIP_CLEAR_HOUR
MOV HOUR,#0
SKIP_CLEAR_HOUR:
CALL PRINT_TIME1
EXIT_HOUR_KEY:
RET
MIN_KEY:
MOV A,COMMAND
CJNE A,#'m',EXIT_MIN_KEY
MOV A,MIN
ADD A,#1
DA A
MOV MIN,A
CJNE A,#60H,SKIP_CLEAR_MIN
MOV MIN,#0
SKIP_CLEAR_MIN:
CALL PRINT_TIME1
EXIT_MIN_KEY:
RET
;*************************** MAIN ***************************
main:
ORL TMOD,#1
SETB TR0
MOV SEC,#0
MOV MIN,#55H
MOV HOUR,#17H
MOV TICK,#0
CALL NEWLINE
; main 10ms loop
LOOP:
CALL WAIT_TICK
; following tasks will be executed every 10ms
CALL TICK_LED
CALL UPDATE_CLOCK
CALL GETCHAR
CALL PRINT_TIME
CALL HOUR_KEY
CALL MIN_KEY
JMP LOOP
END
>>>>>>>>>>>>week7:
; SIMPLE MULTITASKING PROGRAM
$MOD51
$NOPRINT
$INCLUDE(MYPAULM2.EQU)
LED equ P1.7
CR EQU 13
GPIO2 equ 200H ; 8-bit input port
DSEG AT 20H
DS 1
FLAG1:
TICK:
SEC:
MIN:
HOUR:
TIMER1:
TIMER2:
TIMER3:
TIMER4:
COMMAND:
DS
DS
DS
DS
DS
DS
DS
DS
DS
1
1
1
1
1
1
1
1
1
CSEG AT 8000H
jmp main
ORG 8100H
; 10ms tick
; ____|____|____|____|____
;
WAIT_TICK:
JNB TF0,$
CLR TF0
ORL TH0,#0DCH
INC TICK
RET
UPDATE_CLOCK:
MOV A,TICK
CJNE A,#100,EXIT_CLOCK
MOV TICK,#0
SETB FLAG1.0
SETB FLAG1.1
SETB FLAG1.2
; flag that signals print time function
; for tick led
; signals print lcd function
MOV A,SEC
ADD A,#1
DA A
MOV SEC,A
CJNE A,#60H,EXIT_CLOCK
MOV SEC,#0
MOV A,MIN
ADD A,#1
DA A
MOV MIN,A
CJNE A,#60H,EXIT_CLOCK
MOV MIN,#0
MOV A,HOUR
ADD A,#1
DA A
MOV HOUR,A
CJNE A,#24H,EXIT_CLOCK
MOV HOUR,#0
EXIT_CLOCK:
RET
; MAKE LED ON EVERY ONE SECOND
; ------______------------------------------______----------------;
|50ms|
;
|-------------------- 1000ms -------|
;
TICK_LED:
JNB
CLR
INC
MOV
FLAG1.1,EXIT1
LED
TIMER1
A,TIMER1
CJNE A,#5,EXIT1
SETB LED
CLR FLAG1.1
MOV TIMER1,#0
EXIT1:
RET
; check serial port every 10ms
; exit: COMMAND == -1 NO CHARACTER
;
COMMAND != -1 ASCII CODE
GETCHAR:
JNB
CLR
MOV
MOV
RET
EXIT2:
RI,EXIT2
RI
A,SBUF
COMMAND,A
MOV COMMAND,#-1
RET
; PRINT TIME TO TERMINAL EVERY SECOND
PRINT_TIME:
JNB FLAG1.0,EXIT_PRINT_TIME
CLR FLAG1.0
PRINT_TIME1:
MOV A,#CR
CALL COUT
MOV A,HOUR
CALL PHEX
MOV A,#':'
CALL COUT
MOV A,MIN
CALL PHEX
MOV A,#':'
CALL COUT
MOV A,SEC
CALL PHEX
EXIT_PRINT_TIME:
RET
HOUR_KEY:
MOV A,COMMAND
CJNE A,#'h',EXIT_HOUR_KEY
MOV A,HOUR
ADD A,#1
DA A
MOV HOUR,A
CJNE A,#24H,SKIP_CLEAR_HOUR
MOV HOUR,#0
SKIP_CLEAR_HOUR:
CALL PRINT_TIME1
EXIT_HOUR_KEY:
RET
MIN_KEY:
MOV A,COMMAND
CJNE A,#'m',EXIT_MIN_KEY
MOV A,MIN
ADD A,#1
DA A
MOV MIN,A
CJNE A,#60H,SKIP_CLEAR_MIN
MOV MIN,#0
SKIP_CLEAR_MIN:
CALL PRINT_TIME1
EXIT_MIN_KEY:
RET
; PRINT BYTE TO LCD
; INPUT BYTE MUST BE TWO DIGITS BCD NUMBER
PRINT_BYTE: PUSH ACC
ANL A,#0F0H
SWAP A
ADD A,#'0'
CALL PUTCH_LCD
POP ACC
ANL A,#0FH
ADD A,#'0'
CALL PUTCH_LCD
RET
PRINT_TIME_LCD:
JNB FLAG1.2, EXIT_PRINT_LCD
CLR FLAG1.2
PRINT_TIME_LCD1:
MOV A,#00H
MOV B,#00H
CALL goto_xy
MOV A,HOUR
CALL PRINT_BYTE
MOV A,#':'
CALL PUTCH_LCD
MOV A,MIN
CALL PRINT_BYTE
MOV A,#':'
CALL PUTCH_LCD
; A = X
; B = Y
MOV A,SEC
CALL PRINT_BYTE
EXIT_PRINT_LCD:
RET
READ_KEY: MOV DPTR,#GPIO2
MOVX A,@DPTR
JB ACC.4, CHECK_NEXT_KEY
MOV A,#1
RET
CHECK_NEXT_KEY:
JB ACC.5, EXIT_CHECK_KEY
MOV A,#2
RET
EXIT_CHECK_KEY:
MOV A,#-1
RET
EXE_KEY:
CALL READ_KEY
CJNE A,#1,EXE_KEY2
MOV A,HOUR
ADD A,#1
DA A
MOV HOUR,A
CJNE A,#24H,SKIP_CLEAR_HOUR1
MOV HOUR,#0
SKIP_CLEAR_HOUR1:
CALL PRINT_TIME_LCD1
EXIT_HOUR_KEY1:
RET
EXE_KEY2: CJNE A,#2,EXIT_KEY2
MOV A,MIN
ADD A,#1
DA A
MOV MIN,A
CJNE A,#60H,SKIP_CLEAR_MIN1
MOV MIN,#0
SKIP_CLEAR_MIN1:
CALL PRINT_TIME_LCD1
EXIT_KEY2:
RET
SCAN_KEY: INC TIMER2
MOV A,TIMER2
CJNE A,#20,EXIT_SCAN
; 200ms
MOV TIMER2,#0
CALL EXE_KEY
EXIT_SCAN: RET
;*************************** MAIN ***************************
main:
ORL TMOD,#1
SETB TR0
MOV SEC,#0
MOV MIN,#55H
MOV HOUR,#17H
MOV TICK,#0
CALL NEWLINE
CALL INITLCD
; main 10ms loop
LOOP:
CALL WAIT_TICK
; following tasks will be executed every 10ms
CALL TICK_LED
CALL UPDATE_CLOCK
CALL GETCHAR
CALL PRINT_TIME
CALL HOUR_KEY
CALL MIN_KEY
CALL PRINT_TIME_LCD
CALL SCAN_KEY
JMP LOOP
$include(lcddrv.asm)
END
>>>>>>>>>>>.
; LCD driver for 8051SBC
BUSY
EQU 80H
; below LCD's registers are mapped into external data memory
command_write
data_write
command_read
data_read
EQU
EQU
EQU
EQU
0000H
0001H
0002H
0003H
CSEG
; wait until LCD ready bit set
LcdReady:
?ready:
PUSH ACC
MOV DPTR,#command_read
MOVX A,@DPTR
JB ACC.7,?ready
; loop if busy flag = 1
POP ACC
RET
LCD_command_write: CALL LcdReady
MOV DPTR,#command_write
MOVX @DPTR,A
RET
LCD_data_write: PUSH DPL
PUSH DPH
CALL LcdReady
MOV DPTR,#data_write
MOVX @DPTR,A
POP DPH
POP DPL
RET
clr_screen:
CALL LcdReady
MOV A,#1
CALL LCD_command_write
RET
InitLcd:
MOV A,#38H
CALL LCD_command_write
MOV A,#0CH
CALL LCD_command_write
CALL clr_screen
MOV A,#00H
; A = X
MOV B,#00H
; B = Y
CALL goto_xy
RET
; goto_xy(x,y)
; entry: A = y position
;
B = x position
goto_xy:
CJNE A,#0,case1
MOV A,B
ADD A,#80H
CALL LCD_command_write
RET
case1:
CJNE A,#1,case2
MOV A,B
ADD A,#0C0H
CALL LCD_command_write
RET
case2:
RET
; send_string
; entry: DPTR
send_string:
MOVX A,@DPTR
CJNE A,#0,send_string1
send_string1:
RET
CALL LCD_data_write
INC DPTR
JMP send_string
; write ASCII code to LCD at current position
; entry: A
putch_lcd:
CALL LcdReady
CALL LCD_data_write
RET
>>>>>>>>>>>>>>>
After you have understood the tutorialon Introduction to assembly language which includes simple
instruction sets like input/output operations, now its time to learn how to create loops, function calls
and jumps while writing a code in assembly language.
Let us first discuss an important concept that relates RAM & ROM. You can skip this section if you wish
but it is an important to understand registers which helps in building up understanding of architecture
of microcontrollers.
How a program which is burned in ROM gets executed in RAM?
The program you write is burned in ROM and this program is executed in RAM. The data burned is in
the form of logics or binary digits (0 & 1) also called an Opcode or machine code. The programwritten
in assembly language is converted to opcode by assembler.
Each line of the assembly code is assigned a unique opcode by the assembler as shown below. These
opcodes are then stored in ROM one after another. There is a register called Program Counter
(PC) which always points to the current opcode being executed. When the power is switched on it sets
itself to zero and it keeps on incrementing itself as opcodes are executed one after another.
Thisinformation is used by RAM to extract correct opcode from ROM which is then executed. This
process goes on line by line till the whole program is executed.
Lets take an example:PC
Mnemonic, Operand
0000
ORG
0H
0000
MOV
R0, #0
0002
MOV
A, #55H
0004
JZ
0006
0007
AGAIN:
0008
0009
7800
7455
6003
INC
R0
08
INC
04
INC
04
ADD
A, #77H
000B
JNC
OVER
5005
000D
CLR
E4
000E
MOV
R0, A
F8
000F
MOV
R1, A
F9
0010
MOV
R2, A
FA
0011
MOV
R3, A
FB
ADD,
R3
2B
JNC
AGAIN
50F2
0012
NEXT:
NEXT
Opcode (Machine code)
OVER:
0013
0015
HERE:
0017
SJMP
HERE
2477
80FE
END
We can clearly see that the PC increases with execution of program. The PC starts with zero when
ORG 00H line is executed and then in subsequent lines PC keeps on incrementing as machine codes
are executed one after another.
Program Counter is a 2 byte or 16 bit register. Therefore we cannot have internal ROM of more than
the number this register can hold (i.e. not exceeding the FFFF hex value).
LOOP AND JUMP INSTRUCTIONS
Let us start with a simple example that will help you to learn how to create loops in assembly. In the
following code the instruction DJNZ is used to reduce the counter and is repeated till the counter
becomes zero.
Eg-1:
AGAIN:
ORG
0H
MOV
A, #0
; clear A
MOV
R1, #10
; load counter R1 =10
ADD
A, # 05
; add five to register A
DJNZ
R1, AGAIN
; repeat until R1=0 (10 times)
MOV
R3, A
; save A in R3
END
In this code R1 acts as a counter. The counter value is initialized i.e. 10 HEX is loaded to R1. In each
iteration, the instruction DJNZ decrements R1 by one until it becomes zero. This loop adds 5 HEX to A
every time it runs. After ten iterations R1 becomes zero and the instructions below it are executed.
Note: - Some Jump statements can only be performed on some special register A (or bit CY) as
mentioned in the table below.
Nested loops:
ORG 0H
MOV
A, #55H
; A= 55 hex
MOV
R1, #100
; the outer counter R1 =100
NEXT:
MOV
R2, # 20
; the inner counter
AGAIN:
CPL
A, # 05
; add five to register A
DJNZ
R2, AGAIN
; repeat until R1=0 (100 times)
DJNZ
R1, NEXT
; repeat till 20 times (outer loop)
END
SJMP refers to short jump and LJMP refers to long jump. All the conditional jumps are short jumps.
SJMP: This instruction is of two bytes in which first one is opcode & second is the address. The
relative address of the instruction called should be in between -127 to 127 bytes from the
currentprogram counter (PC).
LJMP: This instruction is of three bytes in which the first is the opcode and the second & third are for
address. The relative address of the instruction can be anywhere on the ROM.
So it is clear from the above examples that we can use different jump instructions with a
condition or counter called conditional loop. And when we create loop inside an existing
loop it is called nested loop.
CALL INSTRUCTIONS:
Example:
LCALL (long call)
ORG
BACK :
0H
MOV
A, #55H
; load A= 55 hex value
MOV
P1, A
; issue value of register A to port1
LCALL DELAY
; to call DELAY function created below
MOV A, #0AAH
;load AAH hex value to A
MOV P1,A
;issue value of register A to port 1
LCALL
DELAY
SJMP
BACK
; to call DELAY function as created below
; keep doing this
; ________ this is the delay subroutine
DELAY:
MOV
AGAIN:
DJNZ
RET
R5, #0FFH
R5, AGAIN
; R5= 255 hex, the counter
; stay here until R5 becomes zero
; return to caller
END
In this code we keep on toggling the value of the register of port 1 with two different hex values and a
DELAY subroutine is used to control how fast the value is changing. Here in DELAY subroutine
theprogram is kept busy by running an idle loop and counting 256 counts. After the DELAY subroutine
is executed once the value of port 1 is toggled and this process goes on infinitely.
By using DELAY we can create PWM (Pulse Width Modulation) to control motors or LED blinking for
further details view our tutorial on Input/ output instructions in Assembly Language[coming soon].
We can also use ACALL i.e. absolute call for calling a subroutine that is within 2K byte of PC.
http://www.botskool.com/tutorials/electronics/8051/input-output-instructions-8051assembly-language
http://www.botskool.com/tutorials/electronics/8051/input-output-instructions-8051assembly-language
http://www.hobbyprojects.com/8051_tutorial/
http://www.docstoc.com/docs/112797230/8051-Tutorial-en#
Code ASM 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
[collapse]
org 0000h
sjmp start
org 0050h
start:
mov a,#00h
setb p0.0
x:jnb p1.0,is1
jnb p1.1,ds2
cjne a,#00h,x11
sjmp x
x11:
clr p0.0
mov r2,a
x1: lcall delay
djnz r2,x1
setb p0.0
mov r1,a
mov a,#64h
subb a,r1 ; a = a - r1
mov r2,a
; result into r2 reg
mov a,r1 ; a old value from r1
x12:
lcall delay
djnz r2,x12
sjmp x
is1:
add a,#10h
loop: jnb p1.0,loop
sjmp x11
ds2:
subb a,#10h
loop1: jnb p1.1,loop1
Code ASM 38
39
40
41
42
43
44
[collapse]
sjmp x11
delay:
mov r3,#0ffh
q:djnz r3,q
ret
end
