chapter 2 hcs12 assembly programming. three sections of a hcs12/mc9s12 assembly program assembler...
Post on 21-Dec-2015
286 views
TRANSCRIPT
Chapter 2
HCS12 Assembly Programming
Three Sections of a HCS12/MC9S12 Assembly Program
• Assembler directives– Defines data and symbol– Reserves and initializes memory locations– Sets assembler and linking condition– Specifies output format– Specifies the end of a program
• Assembly language instructions– HCS12/MC9S12 instructions
• Comments– Explains the function of a single or a group of instructions
Fields of a HCS12 Instruction• Label field
– Optional– Starts with a letter and
followed by letters, digits, or special symbols (_ or .)
– Can start from any column if ended with “:”
– Must start from column 1 if not ended with “:”
• Operation field– Contains the mnemonic of a
machine instruction or an assembler directive
– Separated from the label by at least one space
• Operand field– Follows the operation field and
is separated from the operation field by at least one space
– Contains operands for instructions or arguments for assembler directives
• Comment field– Any line starts with an * or ; is
a comment– Separated from the operand
and operation field for at least one space
– Optional
Exampleloop ADDA #$40 ; add 40 to accumulator A
(1) “loop” is a label(2) “ADDA” is an instruction mnemonic(3) “#$40” is the operand(4) “add #$40 to accumulator A” is a comment
movb 0,X,0,Y ; memory to memory copy
(1) no label field(b) “movb” is an instruction mnemonic(c) “0,X,0,Y” is the operand field(d) “; memory to memory copy” is a comment
Identify the Four Fields of an Instruction
Assembler Directives• END
– Ends a program to be processed by an assembler– Any statement following the END directive is ignored.
• ORG– The assembler uses a location counter to keep track of the memory
location where the next machine code byte should be placed.– This directive sets a new value for the location counter of the
assembler.– The sequence
ORG $1000LDAB #$FFplaces the opcode byte for the instruction LDAB #$FF at
location $1000.
dc.b (define constant byte)db (define byte)fcb (form constant byte)- These three directives define the value of a byte or bytes that will be placed at a given
location. - These directives are often preceded by the org directive.- For example,
org $800array dc.b $11,$22,$33,$44
dc.w (define constant word)dw (define word)fdb (form double bytes)- Define the value of a word or words that will be placed at a given location.- The value can be specified by an expression.- For example,vec_tab dc.w $1234, abc-20
fcc (form constant character)• Used to define a string of characters (a message)• The first character (and the last character) is used as the
delimiter. • The last character must be the same as the first
character.• The delimiter must not appear in the string.• The space character cannot be used as the delimiter.• Each character is represented by its ASCII code.• Example
msg fcc “Please enter 1, 2 or 3:”
fill (fill memory)- This directive allows the user to fill a certain number of memory locations with a given value.- The syntax is fill value,count- Example
space_line fill $20,40
ds (define storage)
rmb (reserve memory byte)
ds.b (define storage bytes)- Each of these directives reserves a number of bytes given as the arguments to the directive.- Example
buffer ds 100reserves 100 bytes
ds.w (define storage word)
rmw (reserve memory word)- Each of these directives increments the location counter by the value indicated in the number-of-words argument multiplied by two.- Example
dbuf ds.w 20reserves 40 bytes starting from the current location counter
equ (equate)- This directive assigns a value to a label.- Using this directive makes one’s program more readable.- Examples
arr_cnt equ 100oc_cnt equ 50
loc - This directive increments and produces an internal counter used in conjunction with the backward tick mark (`). - By using the loc directive and the ` mark, one can write program segments like the following example, without thinking up new labels:
loc locldaa #2 ldaa #2
loop` deca same as loop001 decabne loop` bne loop001loc loc
loop` brclr 0,x,$55,loop` loop002 brclr 0,x,$55,loop002
Macro- A name assigned to a group of instructions- Use macro and endm to define a macro.- Example of macro
sumOf3 macro arg1,arg2,arg3ldaa arg1adda arg2adda arg3endm
- Invoke a defined macro: write down the name and the arguments of the macrosumOf3 $1000,$1001,$1002
is replaced by ldaa $1000adda $1001adda $1002
Software Development Process• Problem definition: Identify what should be done.
– Develop the algorithm. • Algorithm is the overall plan for solving the problem at hand.• An algorithm is often expressed in the following format:
– Step 1– …– Step 2– …
– Another way to express overall plan is to use flowchart.• Programming. Convert the algorithm or flowchart into
programs.• Program testing• Program maintenance
Terminal
Process
Input oroutput
Decisionyes
no
Subroutine
A
B
A
on-page connector
off-page connector
Figure 2.1 Flowchart symbols used in this book
Symbols of Flowchart
Example 2.4 Write a program to add the values of memory locations at $1000, $1001, and $1002, and save the result at $1100. Solution:Step 1 A m[$1000]Step 2A A + m[$1001]Step 3A A + m[$1002]Step 4$802 A
org $1500ldaa $1000adda $1501adda $1002staa $1100end
Programs to Do Simple Arithmetic (1 of 5)
Example 2.4 Write a program to subtract the contents of the memory location at $1005 from the sum of the memory locations at $1000 and $1002, and store the difference at $1100.
Solution:
org $1500
ldaa $1000
adda $1002
suba $1005
staa $1000
end
Start
A [$1000]
A [A]+[$1002]
A [A]+[$1005]
$1010 [A]
Stop
Figure 2.2 Logic flow of program 2.4
Programs to Do Simple Arithmetic (2 of 5)
Example 2.6 Write a program to add two 16-bit numbers that are stored at $1000-$1001 and $1002-$1003 and store the sum at $1100-$1101.
Solution:
org $1500
ldd $1000
addd$1002
std $1100
end
The Carry Flag- bit 0 of the CCR register- set to 1 when the addition operation produces a carry 1- set to 1 when the subtraction operation produces a borrow 1- enables the user to implement multi-precision arithmetic
Programs to Do Simple Arithmetic (3 of 5)
Example 2.7 Write a program to add two 4-byte numbers that are stored at $1000-$1003 and $1004-$1007, and store the sum at $1010-$1013.Solution: Addition starts from the LSB and proceeds toward MSB.
org $1500ldd $1002 ; add and save the least significant two bytesaddd $1006 ; “std $1012 ; “
ldaa $1001 ; add and save the second most significant bytesadca $1005 ; “staa $1011 ; “
ldaa $1000 ; add and save the most significant bytesadca $1004 ; “staa $1010 ; “end
Programs to Do Simple Arithmetic (4 of 5)
Example 2.8 Write a program to subtract the hex number stored at $1004-$1007 from the the hex number stored at $1000-$1003 and save the result at $1100-$1103.Solution: The subtraction starts from the LSBs and proceeds toward the MSBs.
org $1500ldd $1002 ; subtract and save the least significant two bytessubd$1006 ; “std $1102 ; “
ldaa $1001 ; subtract and save the difference of the second to mostsbca$1005 ; significant bytesstaa $1001 ; “
ldaa $1000 ; subtract and save the difference of the most significant sbca$1004 ; bytesstaa $1100 ; “end
Programs to Do Simple Arithmetic (5 of 5)
BCD Numbers and Addition
• Each digit is encoded by 4 bits.• Two digits are packed into one byte• The addition of two BCD numbers is performed by binary addition
and an adjust operation using the DAA instruction.• The instruction DAA can be applied after the instructions ADDA,
ADCA, and ABA.• Simplifies I/O conversion• For example, the instruction sequence
– LDAA $1000– ADDA $1001– DAA– STAA $1002adds the BCD numbers stored at $1000 and $1001 and saves the sum at
$1002.
Table 2.1 Summary of HCS12 multiply and divide instructions
Mnemonic
emulemulsmul
ediv
edivs
fdiv
idiv
idivs
Function
unsigned 16 by 16 multiplysigned 16 by 16 multiplyunsigned 8 by 8 multiply
unsigned 32 by 16 divide
signed 32 by 16 divide
16 by 16 fractional divide
unsigned 16 by 16 integerdividesigned 16 by 16 integerdivide
(D) × (Y) Y:D(D) × (Y) Y:D(A) × (B) A:B(Y:D) ÷ (X)quotient Yremainder D(Y:D) ÷ (X)quotient Yremainder D(D) ÷ (X) Xremainder D(D) ÷ (X) Xremainder D(D) ÷ (X) Xremainder D
Operation
Multiplication and Division (1 of 2)
Example 2.10 Write an instruction sequence to multiply the 16-bit numbers stored at $1000-$1001 and $1002-$1003 and store the product at $1100-$1103.
Solution:ldd $1000ldy $1002emulsty $1100std $1102
Example 2.11 Write an instruction sequence to divide the 16-bit number stored at $1020-$1021 into the 16-bit number stored at $1005-$1006 and store the quotient and remainder at $1100 and $1102, respectively.
Solution:ldd $1005ldx $1020idivstx $1100 ; store the quotientstd $1102 ; store the remainder
Multiplication and Division (2 of 2)
16-bit
P ~ P+1 P+2 ~ P+3 P+4 ~ P+5 P+6 ~ P+7
upper half
upper half
upper half
upper half lower half
lower half
lower half
lower half
Address
partial product MLNL
partial product MHNL
partial product MLNH
partial product MHNH
Final product M × N
msb lsb
Note: msb stands for most significant byte and lsb for least significant byte
Figure 2.3 Unsigned 32-bit by 32-bit multiplication
16-bit 16-bit 16-bit
Illustration of 32-bit by 32-bit Multiplication• Two 32-bit numbers M and N are divided into two 16-bit halves
– M = MHML
– N = NHNL
Example 2.12 Write a program to multiply two unsigned 32-bit numbers stored at M~M+3 and N~N+3, respectively and store the product at P~P+7.Solution:
org $1000M ds.b 4N ds.b 4P ds.b 8
org $1500ldd M+2ldy N+2emul ; compute MLNL
sty P+4std P+6ldd Mldy Nemul ; compute MHNH
sty Pstd P+2ldd Mldy N+2emul ; compute MHNL
; add MHNL to memory locations P+2~P+5addd P+4std P+4tfr Y,Dadcb P+3stab P+3adca P+2staa P+2
; propagate carry to the most significant byteldaa P+1adca #0 ; add carry to the location at P+1staa P+1 ; “ldaa P ; add carry to the location at Padca #0 ; “staa P ; “
; compute MLNH
ldd M+2ldy Nemul
; add MLNH to memory locations P+2 ~ P+5addd P+4std P+4tfr Y,Dadcb P+3stab P+3adca P+2staa P+2
; propagate carry to the most significant byteclraadca P+1staa P+1ldaa Padca #0staa Pend
Example 2.13 Write a program to convert the 16-bit number stored at $1000-$1001 to BCD format and store the result at $1010-$1014. Convert each BCD digit into its ASCII code and store it in one byte.Solution: - A binary number can be converted to BCD format by using repeated division by 10.- The largest 16-bit binary number is 65535 which has five decimal digits.- The first division by 10 generates the least significant digit, the second division by 10 obtains the second least significant digit, and so on.
org $1000data dc.w 12345 ; data to be tested
org $1010result ds.b 5 ; reserve bytes to store the result
org $1500ldd dataldy #resultldx #10idivaddb #$30 ; convert the digit into ASCII codestab 4,Y ; save the least significant digitxgdxldx #10
idivadcb #$30stab 3,Y ; save the second to least significant digitxgdxldx #10idivaddb #$30stab 2,Y ; save the middle digitxgdxldx #10idivaddb #$30stab 1,Y ; save the second most significant digitxgdxaddb #$30stab 0,Y ; save the most significant digitend
Program Loops• Types of program loops: finite and infinite loops• Looping mechanisms:
– do statement S forever– For i = n1 to n2 do statement S or For i = n2 downto n1 do
statement S– While C do statement S– Repeat statement S until C
• Program loops are implemented by using the conditional branch instructions and the execution of these instructions depends on the contents of the CCR register.
Figure 2.4 An infinite loop
S
Figure 2.5 For looping construct
I i1
I i2 ?
S
yes
I I + 1
(a) For I = i1 to i2 DO S
no
I i2
I i1 ?
S
yes
I I - 1
(b) For I = i2 downto i1 DO S
no
C Strue
false
Figure 2.6 The While ... Do looping construct
Figure 2.7 The Repeat ... Until looping construct
initialize C
S
Ctrue
false
S X I
7 6 5 4 3 2 1 0
Figure 2.8 Condition code register
H N Z V C
Condition Code Register
• Four types of branch instructions– Unary (unconditional) branch: always execute– Simple branches: branch is taken when a specific bit of CCR is in a
specific status– Unsigned branches: branches are taken when a comparison or test of
unsigned numbers results in a specific combination of CCR bits– Signed branches: branches are taken when a comparison or test of
signed quantities are in a specific combination of CCR bits
• Two categories of branches– Short branches: in the range of -128 ~ +127 bytes– Long branches: in the range of 64KB
Table 2.2 Summary of short branch instructions
Mnemonic Function
Unary Branches
BRABRN
Branch alwaysBranch never
Equation or Operation
Simple Branches
Mnemonic Function
BCCBCSBEQBMIBNEBPLBVCBVS
Branch if carry clearBranch if carry setBranch if equalBranch if minusBranch if not equalBranch if plusBranch if overflow clearBranch if overflow set
1 = 11 = 0
Unsigned Branches
Mnemonic Function
BHIBHSBLOBLS
Branch if higherBranch if higher or sameBranch if lowerBranch if lower or same
C = 0C = 1Z = 1N = 1Z = 0N = 0V = 0V = 1
Equation or Operation
Equation or Operation
C + Z = 0C = 0C = 1
C + Z = 1
Mnemonic Function Equation or Operation
Signed Branches
BGEBGTBLEBLT
Branch if greater than or equalBranch if greater thanBranch if less than or equalBranch if less than
N V = 0Z + (N V) = 0Z + (N V) = 1
N V = 1
Table 2.3 Summary of long branch instructions
Mnemonic Function
Unary Branches
LBRALBRN
Long branch alwaysLong branch never
Equation or Operation
Simple Branches
Mnemonic Function
LBCCLBCSLBEQLBMILBNELBPLLBVCLBVS
Long branch if carry clearLong branch if carry setLong branch if equalLong branch if minusLong branch if not equalLong branch if plusLong branch if overflow is clearLong branch if overflow set
1 = 11 = 0
Unsigned Branches
Mnemonic Function
LBHILBHSLBLOLBLS
Long branch if higherLong branch if higher or sameLong branch if lowerLong branch if lower or same
C = 0C = 1Z = 1N = 1Z = 0N = 0V = 0V = 1
Equation or Operation
Equation or Operation
C + Z = 0C = 0C = 1
C + Z = 1
Mnemonic Function Equation or Operation
Signed Branches
LBGELBGTLBLELBLT
Long branch if greater than or equalLong branch if greater thanLong branch if less than or equalLong branch if less than
N V = 0Z + (N V) = 0Z + (N V) = 1
N V = 1
Table 2.4 Summary of compare and test instructions
Mnemonic Function
Compare instructions
CBACMPACMPBCPDCPSCPXCPY
Compare A to BCompare A to memoryCompare B to memoryCompare D to memoryCompare SP to memoryCompare X to memoryCompare Y to memory
Operation
(A) - (B)(A) - (M)(B) - (M)
(D) - (M:M+1)(SP) - (M:M+1)(X) - (M:M+1)(Y) - (M:M+1)
Test instructions
Mnemonic Function
TSTTSTATSTB
Test memory for zero or minusTest A for zero or minusTest B for zero or minus
Operation
(M) - $00(A) - $00(B) - $00
Compare and Test Instructions• Condition flags need to be set up before conditional branch
instruction should be executed.• The HCS12 provides a group of instructions for testing the condition
flags.
Table 2.5 Summary of loop primitive instructions
Mnemonic Function
DBEQ cntr, rel
DBNE cntr, rel
IBEQ cntr, rel
IBNE cntr, rel
TBEQ cntr, rel
TBNE cntr, rel
Decrement counter and branch if = 0(counter = A, B, D, X, Y, or SP)
Decrement counter and branch if 0(counter = A, B, D, X, Y, or SP)
Increment counter and branch if = 0(counter = A, B, D, X, Y, or SP)
Increment counter and branch if 0(counter = A, B, D, X, Y, or SP)
Test counter and branch if = 0(counter = A, B, D, X, Y, or SP)
Test counter and branch if 0(counter = A, B, D, X, Y, or SP)
Equation or Operation
counter (counter) - 1If (counter) = 0, then branchelse continue to next instructioncounter (counter) - 1If (counter) 0, then branchelse continue to next instructioncounter (counter) + 1If (counter) = 0, then branchelse continue to next instructioncounter (counter) + 1If (counter) 0, then branchelse continue to next instructionIf (counter) = 0, then branchelse continue to next instruction
If (counter) 0, then branchelse continue to next instruction
Note. 1. cntr is the loop counter and can be accumulator A, B, or D and register X, Y, or SP. 2. rel is the relative branch offset and is usually a label
Loop Primitive Instructions
• HCS12 provides a group of instructions that either decrement or increment a loop count to determine if the looping should be continued.
• The range of the branch is from $80 (-128) to $7F (+127).
Example 2.14 Write a program to add an array of N 8-bit numbers and store the sum at memory locations $1000~$1001. Use the For i = n1 to n2 do looping construct.
Solution:Start
i 0sum 0
i = N?
no
sum sum + array[i]
i i + 1
Stop
Figure 2.9 Logic flow of example 2.14
yes
N equ 20org $1000
sum rmb 2i rmb 1
org $1500ldaa #0staa istaa sum ; sum 0staa sum+1 ; “
loop ldab icmpb #N ; is i = N?beq doneldx #arrayabxldab 0,X ; sum sum + array[i]ldy sum ; “aby ; “sty sum ; “
inc i ; increment the loop count by 1bra loop
done swiarray dc.b 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20
end
Example 2.15 Write a program to find the maximum element from an array of N 8-bit elements using the repeat S until C looping construct.Solution:
Start
max_val array[0]i N-1
max_val < array[i] ?
max_val array[i]
yes
no
i i - 1
i = 0?
Stop
yes
no
Figure 2.10 Logic flow of example 2.15
N equ 20org $1000
max_val ds.b 1org $1500ldaa array ; set array[0] as the temporary max maxstaa max_val ; “ldx #array+N-1 ; start from the end of the array ldab #N-1 ; set loop count to N - 1
loop ldaa max_valcmpa 0,xbge chk_endldaa 0,xstaa max_val
chk_end dexdbne b,loop ; finish all the comparison yet?
forever bra foreverarray db 1,3,5,6,19,41,53,28,13,42,76,14
db 20,54,64,74,29,33,41,45end
[<label>] brclr (opr),(msk),(rel) [<comment>][<label>] brset (opr),(msk),(rel) [<comment>]
whereopr specifies the memory location to be checked and must be specified using either
the direct, extended, or index addressing mode.msk is an 8-bit mask that specifies the bits of the memory location to be checked.
The bits of the memory byte to be checked correspond to those bit positions that are 1s in the mask.
rel is the branch offset and is specified in the 8-bit relative mode.
For example, in the sequenceloop inc count
… brclr $66,$e0,loop
…the branch will be taken if the most significant three bits at $66 are all ones.
Bit Condition Branch Instructions
Example 2.17 Write a program to compute the number of elements that are divisible by 4 in an array of N 8-bit elements. Use the repeat S until C looping construct.Solution: A number divisible by 4 would have the least significant two bits equal 0s.
N equ 20org $1000
total ds.b 1org $1500clr total ; initialize total to 0ldx #arrayldab #N ; use B as the loop count
loop brclr 0,x,$03,yes ; check bits 1 and 0bra chkend
yes inc totalchkend inx
dbne b,loopforever bra foreverarray db 2,3,4,8,12,13,19,24,33,32,20,18,53,52,80,82,90,94,100,102
end
Instructions for Variable Initialization
• [<label>] CLR opr [<comment>]where opr is specified using the extended or index addressing modes. The specified memory location is cleared.
• [<label>] CLRA [<comment>]Accumulator A is cleared to 0
• [<label>] CLRB [<comment>]Accumulator B is cleared to 0
The HCS12 has shift and rotate instructions that apply to a memory location, accumulators A, B, and D. A memory operand must be specified using the extended or index addressing modes.
There are three 8-bit arithmetic shift left instructions:
[<label>] asl opr [<comment>] -- memory location opr is shifted left one place[<label>] asla [<comment>] -- accumulator A is shifted left one place[<label>] aslb [<comment>] -- accumulator B is shifted left one place
The operation is
C 0b7 ----------------- b0
Shift and Rotate Instructions
The HCS12 has arithmetic shift right instructions that apply to a memory location and accumulators A and B.
[<label>] asr opr [<comment>] -- memory location opr is shifted right one place [<label>] asra [<comment>] -- accumulator A is shifted right one place[<label>] asrb [<comment>] -- accumulator B is shifted right one place
The operation is
Cb7 ----------------- b0
The HCS12 has one 16-bit arithmetic shift left instruction:
[<label>] asld [<comment>]
The operation is
C 0b7 ----------------- b0 b7 ----------------- b0accumulator A accumulator B
The HCS12 has logical shift left instructions that apply to a memory location and accumulators A and B.
[<label>] lsl opr [<comment>] -- memory location opr is shifted left one place [<label>] lsla [<comment>] -- accumulator A is shifted left one place[<label>] lslb [<comment>] -- accumulator B is shifted left one place
The operation is
C b7 ----------------- b0 0
The HCS12 has one 16-bit logical shift left instruction:
[<label>] lsld [<comment>]
The operation is
C 0b7 ----------------- b0 b7 ----------------- b0
accumulator A accumulator B
The HCS12 has three logical shift right instructions that apply to 8-bit operands.
[<label>] lsr opr [<comment>] -- memory location opr is shifted right one place [<label>] lsra [<comment>] -- accumulator A is shifted right one place[<label>] lsrb [<comment>] -- accumulator B is shifted right one place
The operation isCb7 ----------------- b00
The HCS12 has one 16-bit logical shift right instruction:
[<label>] lsrd [<comment>]
The operation is
C0 b7 ----------------- b0 b7 ----------------- b0
accumulator A accumulator B
The HCS12 has three rotate left instructions that operate on 9-bit operands.
[<label>] rol opr [<comment>] -- memory location opr is rotated left one place [<label>] rola [<comment>] -- accumulator A is rotated left one place[<label>] rolb [<comment>] -- accumulator B is rotated left one place
The operation isCb7 ----------------- b0
The HCS12 has three rotate right instructions that operate on 9-bit operands.
[<label>] ror opr [<comment>] -- memory location opr is rotated right one place [<label>] rora [<comment>] -- accumulator A is rotated right one place[<label>] rorb [<comment>] -- accumulator B is rotated right one place
The operation is
C b7 ----------------- b0
Example 2.18 Suppose that [A] = $95 and C = 1. Compute the new values of A and C after the execution of the instruction asla.Solution:
Example 2.19 Suppose that m[$800] = $ED and C = 0. Compute the new values of m[$800] and the C flag after the execution of the instruction asr $1000.Solution:
01 1 110 0 00
1 1 1 10 0 0 0 0
Figure 2.11a Operation of the ASLA instruction
C flag
accumulator A
Original value New value
[A] = 10010101C = 1
[A] = 00101010C = 1
Figure 2.11b Execution result of the ASLA instruction
1 0 111 1 01
11 0 11 1 1 1 0
Figure 2.12a Operation of the ASR $1000 instruction
memory location$1000
C flag Original value New value
[$1000] = 11101101C = 0
[$1000] = 11110110C = 1
Figure 2.12b Result of the asr $1000 instruction
Example 2.20 Suppose that m[$1000] = $E7 and C = 1. Compute the new contents of m[$1000] and the C flag after the execution of the instruction lsr $1000.Solution:
Example 2.21 Suppose that [B] = $BD and C = 1. Compute the new values of B and the C flag after the execution of the instruction rolb.Solution:
1 0 111 1 10
11 0 10 1 1 0 1
Figure 2.13a Operation of the LSR $800 instruction
0
memorylocation$800
C flag Original value New value
[$800] = 11100111C = 1
[$800] = 01110011C = 1
Figure 2.13b Execution result of LSR $800
1 1 1 1 1 0 10
0 01 1 1 1 1 1 1
1
Figure 2.14a Operation of the instruction ROLB
accumulator B
C flagOriginal value New value
[B] = 10111101C = 1
[B] = 01111011C = 1
Figure 14b. Execution result of ROLB
Example 2.22 Suppose that [A] = $BE and C = 1. Compute the new values of mem[$00] after the execution of the instruction rora.Solution:
1 1 0 1 1 1 1 1 0
0 1 1 1 1 1 1 10
Figure 2.15a Operation of the instruction rora
accumulator A
C flag
Original value New value
[A] = 10111110C = 1
[A] = 11011111C = 0
Figure 2.15b Execution result of rora
Example 2.23 Write a program to count the number of 0s in the 16-bit number stored at $1000-$1001 and save the result in $1005.Solution:* The 16-bit number is shifted to the right 16 time.* If the bit shifted out is a 0 then increment the 0s count by 1.
org $1000db $23,$55 ; test dataorg $1005
zero_cnt rmb 1lp_cnt rmb 1
org $1500clr zero_cnt ; initialize the 0s count to 0ldaa #16staa lp_cntldd $1000 ; place the number in D
loop lsrd ; shift the lsb of D to the C flagbcs chkend ; is the C flag a 0?inc zero_cnt ; increment 1s count if the lsb is a 1
chkend dec lp_cnt ; check to see if D is already 0bne loop
forever bra foreverend
Shift a Multi-byte Number (1 of 3)
• For shifting right– The bit 7 of each byte will receive the bit 0 of its immediate left
byte with the exception of the most significant byte which will receive a 0.
– Each byte will be shifted to the right by 1 bit. The bit 0 of the least significant byte will be lost.
• Suppose there is a k-byte number that is stored at loc to loc+k-1.– Method for shifting right
• Step 1: Shift the byte at loc to the right one place.• Step 2: Rotate the byte at loc+1 to the right one place.• Step 3: Repeat Step 2 for the remaining bytes.
Shift a Multi-byte Number (2 of 3)
• For shifting left– The bit 0 of each byte will receive the bit 7 of its immediate right
byte with the exception of the least significant byte which will receive a 0.
– Each byte will be shifted to the left by 1 bit. The bit 7 of the most significant byte will be lost.
• Suppose there is a k-byte number that is stored at loc to loc+k-1.– Method for shifting left
• Step 1: Shift the byte at loc+k-1 to the left one place.• Step 2: Rotate the byte at loc+K-2 to the left one place.• Step 3: Repeat Step 2 for the remaining bytes.
Example 2.24 Write a program to shift the 32-bit number stored at $820-$823 to the right four places.Solution:
ldab #4 ; set up the loop countldx #$820 ; use X as the pointer to the left most byte
again lsr 0,Xror 1,Xror 2,Xror 3,Xdbne b,againend
Shift a Multi-byte Number (3 of 3)
Table 2.8 Summary of Booleran logic instructions
Mnemonic Function
ANDA <opr>ANDB <opr>ANDCC <opr>EORA <opr>EORB <opr>ORAA <opr>ORAB <opr>ORCC <opr>CLCCLICLVCOM <opr>COMACOMBNEG <opr>NEGANEGB
AND A with memoryAND B with memoryAND CCR with memory (clear CCR bits)Exclusive OR A with memroyExclusive OR B with memoryOR A with memoryOR B with memoryOR CCR with memoryClear C bit in CCRClear I bit in CCRClear V bit in CCROne's complement memoryOne's complement AOne's complement BTwo's complement memoryTwo's complement ATwo's complement B
Operation
A (A) (M)B (B) (M)CCR (CCR) (M)A (A) (M)B (B) (M)A (A) + (M)B (B) + (M)CCR (CCR) + (M)C 0I 0V 0M $FF - (M)A $FF - (A)B $FF - (B)M $00 - (M)A $00 - (A)B $00 - (B)
Boolean Logic Instructions
• Changing a few bits are often done in I/O applications.
• Boolean logic operation can be used to change a few I/O port pins easily.
Program Execution Time (1 of 2)
• The HCS12 uses the E clock as a timing reference.• The frequency of the E clock is half of that of the crystal oscillator.• There are many applications that require the generation of time
delays.• The creation of a time delay involves two steps:
– Select a sequence of instructions that takes a certain amount of time to execute.
– Repeat the selected instruction sequence for an appropriate number of times.
• For example, the instruction sequence on the next page takes 40 E cycles to execute. By repeating this instruction sequence a certain number of times, any time delay can be created.
– Assume that the HCS12 runs under a crystal oscillator with a frequency of 16 MHz, then the E frequency is 8 MHz and, hence, its clock period is 125 ns.
– Therefore, the instruction sequence on the next page will take 5 ms to execute.
loop psha ; 2 E cyclespula ; 3 E cyclespshapulapshapulapshapulapshapulapshapulapshapulanop ; 1 E cyclenop ; 1 E cycledbne x,loop ; 3 E cycles
Program Execution Time (2 of 2)
Example 2.25 Write a program loop to create a delay of 100 ms.Solution: A delay of 100 ms can be created by repeating the previous loop 20,000 times.
The following instruction sequence creates a delay of 100 ms.ldx #20000
loop psha ; 2 E cyclespula ; 3 E cyclespshapulapshapulapshapulapshapulapshapulapshapulanop ; 1 E cyclenop ; 1 E cycledbne x,loop ; 3 E cycles
ldab #100out_loop ldx #20000in_loop psha ; 2 E cycles
pula ; 3 E cyclespshapulapshapulapshapulapshapulapshapulapshapulanop ; 1 E cyclenop ; 1 E cycledbne x,in_loop ; 3 E cyclesdbne b,out_loop ; 3 E cycles
Example 2.26 Write an instruction sequence to create a delay of 10 seconds.Solution: By repeating the previous instruction sequence 100 times, we can create a delay of 10 seconds.