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 :

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

Operation field
Contains the mnemonic of a machine instruction or an assembler directive Separated from the label by at least one space

Comment field
Any line starts with an * or ; is a comment Separated from the operand and operation field for at least one space Optional

Identify the Four Fields of an Instruction

Example
loop 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

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 $1000 LDAB #$FF places 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 $800 array 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 100 reserves 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 20 reserves 40 bytes starting from the current location counter

equ (equate)
- This directive assigns a value to a label. - Using this directive makes ones program more readable. - Examples arr_cnt equ 100 oc_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 loc ldaa #2 ldaa #2 loop` deca same as loop001 deca bne loop` bne loop001 loc 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 ldaa adda adda endm macro arg1 arg2 arg3 arg1,arg2,arg3

- Invoke a defined macro: write down the name and the arguments of the macro sumOf3 $1000,$1001,$1002 is replaced by ldaa $1000 adda $1001 adda $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

Symbols of Flowchart
Terminal A

Process

Subroutine

Input or output

B off-page connector yes

Decision no

A on-page connector

Figure 2.1 Flowchart symbols used in this book

Programs to Do Simple Arithmetic (1 of 5)

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 2 A A + m[$1001] Step 3 A A + m[$1002] Step 4 $802 A org $1500 ldaa $1000 adda $1501 adda $1002 staa $1100 end

Programs to Do Simple Arithmetic (2 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:
Start A [$1000] A [A]+[$1002] A [A]+[$1005] $1010 [A] Stop Figure 2.2 Logic flow of program 2.4

org ldaa adda suba staa end

$1500 $1000 $1002 $1005 $1000

Programs to Do Simple Arithmetic (3 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 (4 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 ldd addd std ldaa adca staa ldaa adca staa end $1500 $1002 ; add and save the least significant two bytes $1006 ; $1012 ; $1001 ; add and save the second most significant bytes $1005 ; $1011 ; $1000 ; add and save the most significant bytes $1004 ; $1010 ;

Programs to Do Simple Arithmetic (5 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 ldd subd std ldaa sbca staa ldaa sbca staa end $1500 $1002 $1006 $1102 $1001 $1005 $1001 $1000 $1004 $1100 ; subtract and save the least significant two bytes ; ; ; subtract and save the difference of the second to most ; significant bytes ; ; subtract and save the difference of the most significant ; bytes ;

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 $1002 adds the BCD numbers stored at $1000 and $1001 and saves the sum at $1002.

Multiplication and Division (1 of 2)

Table 2.1 Summary of HCS12 multiply and divide instructions Operation Mnemonic Function emul emuls mul ediv unsigned 16 by 16 multiply signed 16 by 16 multiply unsigned 8 by 8 multiply unsigned 32 by 16 divide (D) (Y) Y:D (D) (Y) Y:D (A) (B) A:B (Y:D) (X) quotient Y remainder D (Y:D) (X) quotient Y remainder D (D) (X) X remainder D (D) (X) X remainder D (D) (X) X remainder D

edivs fdiv idiv idivs

signed 32 by 16 divide 16 by 16 fractional divide unsigned 16 by 16 integer divide signed 16 by 16 integer divide

Multiplication and Division (2 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 ldy emul sty std

$1000 $1002 $1100 $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 ldx idiv stx std $1005 $1020 $1100 $1102 ; store the quotient ; store the remainder

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
16-bit 16-bit 16-bit 16-bit partial product MLNL partial product MHNL partial product MLNH partial product MHNH P+4 ~ P+5 P+6 ~ P+7 Final product M N lsb

upper half lower half upper half lower half upper half lower half upper half lower half

Address

P ~ P+1 msb

P+2 ~ P+3

Note: msb stands for most significant byte and lsb for least significant byte Figure 2.3 Unsigned 32-bit by 32-bit multiplication

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 $1000 M ds.b 4 N ds.b 4 P ds.b 8 org $1500 ldd M+2 ldy N+2 emul ; compute MLNL sty P+4 std P+6 ldd M ldy N emul ; compute MHNH sty P std P+2 ldd M ldy N+2 emul ; compute MHNL

; add MHNL to memory locations P+2~P+5 addd P+4 std P+4 tfr Y,D adcb P+3 stab P+3 adca P+2 staa P+2 ; propagate carry to the most significant byte ldaa P+1 adca #0 ; add carry to the location at P+1 staa P+1 ; ldaa P ; add carry to the location at P adca #0 ; staa P ; ; compute MLNH ldd M+2 ldy N emul

; add MLNH to memory locations P+2 ~ P+5 addd P+4 std P+4 tfr Y,D adcb P+3 stab P+3 adca P+2 staa P+2 ; propagate carry to the most significant byte clra adca P+1 staa P+1 ldaa P adca #0 staa P end

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.
data result org dc.w org ds.b org ldd ldy ldx idiv addb stab xgdx ldx $1000 12345 $1010 5 $1500 data #result #10 #$30 4,Y ; convert the digit into ASCII code ; save the least significant digit ; data to be tested ; reserve bytes to store the result

#10

idiv adcb stab xgdx ldx idiv addb stab xgdx ldx idiv addb stab xgdx addb stab end

#$30 3,Y #10 #$30 2,Y #10 #$30 1,Y #$30 0,Y

; save the second to least significant digit

; save the middle digit

; save the second most significant digit

; save the most significant digit

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.

S
C false

true S

Figure 2.4 An infinite loop

I i1 no I i2 no

Figure 2.6 The While ... Do looping construct

I i2 ? yes S II+ 1

I i1 ? yes

initialize C

S
S II-1

C false

true

(a) For I = i1 to i2 DO S

(b) For I = i2 downto i1 DO S

Figure 2.7 The Repeat ... Until looping construct

Figure 2.5 For looping construct

Condition Code Register

7 S 6 X 5 H 4 I 3 N 2 Z 1 V 0 C Figure 2.8 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 Unary Branches Mnemonic BRA BRN Mnemonic BCC BCS BEQ BMI BNE BPL BVC BVS Mnemonic BHI BHS BLO BLS Function Branch always Branch never Simple Branches Function Branch if carry clear Branch if carry set Branch if equal Branch if minus Branch if not equal Branch if plus Branch if overflow clear Branch if overflow set Unsigned Branches Function Branch if higher Branch if higher or same Branch if lower Branch if lower or same Signed Branches Mnemonic BGE BGT BLE BLT Function Branch if greater than or equal Branch if greater than Branch if less than or equal Branch if less than Equation or Operation N V= 0 Z + (N V) = 0 Z + (N V) = 1 N V= 1 Equation or Operation 1 =1 1 =0 Equation or Operation C=0 C=1 Z=1 N=1 Z=0 N=0 V=0 V=1 Equation or Operation C + Z= 0 C=0 C=1 C + Z= 1

Table 2.3 Summary of long branch instructions Unary Branches Mnemonic LBRA LBRN Mnemonic LBCC LBCS LBEQ LBMI LBNE LBPL LBVC LBVS Mnemonic LBHI LBHS LBLO LBLS Function Long branch always Long branch never Simple Branches Function Long branch if carry clear Long branch if carry set Long branch if equal Long branch if minus Long branch if not equal Long branch if plus Long branch if overflow is clear Long branch if overflow set Unsigned Branches Function Long branch if higher Long branch if higher or same Long branch if lower Long branch if lower or same Signed Branches Mnemonic LBGE LBGT LBLE LBLT Function Long branch if greater than or equal Long branch if greater than Long branch if less than or equal Long branch if less than Equation or Operation N V= 0 Z + (N V) = 0 Z + (N V) = 1 N V= 1 Equation or Operation 1 =1 1 =0 Equation or Operation C=0 C=1 Z=1 N=1 Z=0 N=0 V=0 V=1 Equation or Operation C + Z= 0 C=0 C=1 C + Z= 1

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.4 Summary of compare and test instructions
Compare instructions Mnemonic CBA CMPA CMPB CPD CPS CPX CPY Function Compare A to B Compare A to memory Compare B to memory Compare D to memory Compare SP to memory Compare X to memory Compare Y to memory Test instructions Mnemonic TST TSTA TSTB Function Test memory for zero or minus Test A for zero or minus Test B for zero or minus Operation (M) - $00 (A) - $00 (B) - $00 Operation (A) - (B) (A) - (M) (B) - (M) (D) - (M:M+1) (SP) - (M:M+1) (X) - (M:M+1) (Y) - (M:M+1)

Loop Primitive Instructions

Table 2.5 Summary of 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).

Mnemonic

Function

Equation or Operation

Decrement counter and branch if = 0 counter (counter) - 1 DBEQ cntr, rel (counter = A, B, D, X, Y, or SP) If (counter) = 0, then branch else continue to next instruction Decrement counter and branch if 0 counter (counter) - 1 DBNE cntr, rel (counter = A, B, D, X, Y, or SP) If (counter) 0, then branch else continue to next instruction Increment counter and branch if = 0 counter (counter) + 1 IBEQ cntr, rel (counter = A, B, D, X, Y, or SP) If (counter) = 0, then branch else continue to next instruction Increment counter and branch if 0 counter (counter) + 1 IBNE cntr, rel (counter = A, B, D, X, Y, or SP) If (counter) 0, then branch else continue to next instruction Test counter and branch if = 0 If (counter) = 0, then branch TBEQ cntr, rel (counter = A, B, D, X, Y, or SP) else continue to next instruction Test counter and branch if 0 TBNE cntr, rel (counter = A, B, D, X, Y, or SP) If (counter) 0, then branch else 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

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:
N sum i equ org rmb rmb org ldaa staa staa staa ldab cmpb beq ldx abx ldab ldy aby sty 20 $1000 2 1 $1500 #0 i sum sum+1 i #N done #array 0,X sum sum
Start i 0 sum 0

; sum 0 ; ; is i = N?

i = N? no sum sum + array[i] i i+ 1

yes

Stop

loop

; sum sum + array[i] ; ; ;

Figure 2.9 Logic flow of example 2.14

done array

inc i ; increment the loop count by 1 bra loop swi 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 8bit elements using the repeat S until C looping construct. Solution:

Start max_val array[0] i N-1

max_val < array[i] ? yes max_val array[i] ii-1

no

no

i = 0? yes Stop

Figure 2.10 Logic flow of example 2.15

equ org max_val ds.b org ldaa staa ldx ldab loop ldaa cmpa bge ldaa staa chk_end dex dbne forever bra array db db end

20 $1000 1 $1500 array max_val #array+N-1 #N-1 max_val 0,x chk_end 0,x max_val

; set array[0] as the temporary max max ; ; start from the end of the array ; set loop count to N - 1

b,loop ; finish all the comparison yet? forever 1,3,5,6,19,41,53,28,13,42,76,14 20,54,64,74,29,33,41,45

Bit Condition Branch Instructions

[<label>] brclr (opr),(msk),(rel) [<comment>] [<label>] brset (opr),(msk),(rel) [<comment>]

where opr 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 sequence loop inc count brclr $66,$e0,loop the branch will be taken if the most significant three bits at $66 are all ones.

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 org total ds.b org clr ldx ldab loop brclr bra yes inc chkend inx dbne forever bra array db end 20 $1000 1 $1500 total ; initialize total to 0 #array #N ; use B as the loop count 0,x,$03,yes ; check bits 1 and 0 chkend total b,loop forever 2,3,4,8,12,13,19,24,33,32,20,18,53,52,80,82,90,94,100,102

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

Shift and Rotate Instructions

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>] [<label>] asla [<comment>] [<label>] aslb [<comment>] -- memory location opr is shifted left one place -- accumulator A is shifted left one place -- accumulator B is shifted left one place

The operation is
C b7 ----------------- b0

The HCS12 has one 16-bit arithmetic shift left instruction:

[<label>] asld The operation is [<comment>]

b7 ----------------- b0 accumulator A

b7 ----------------- b0 accumulator B

The HCS12 has arithmetic shift right instructions that apply to a memory location and accumulators A and B.
[<label>] asr opr [<comment>] [<label>] asra [<comment>] [<label>] asrb [<comment>] The operation is -- memory location opr is shifted right one place -- accumulator A is shifted right one place -- accumulator B is shifted right one place

b7 ----------------- b0

The HCS12 has logical shift left instructions that apply to a memory location and accumulators A and B.
[<label>] lsl opr [<label>] lsla [<label>] lslb The operation is C b7 ----------------- b0 0 [<comment>] [<comment>] [<comment>] -- memory location opr is shifted left one place -- accumulator A is shifted left one place -- accumulator B is shifted left one place

The HCS12 has one 16-bit logical shift left instruction:

[<label>] lsld The operation is [<comment>]

b7 ----------------- b0

b7 ----------------- b0
accumulator B

accumulator A

The HCS12 has three logical shift right instructions that apply to 8-bit operands.
[<label>] lsr opr [<label>] lsra [<label>] lsrb The operation is [<comment>] [<comment>] [<comment>] 0 -- memory location opr is shifted right one place -- accumulator A is shifted right one place -- accumulator B is shifted right one place C

b7 ----------------- b0

The HCS12 has one 16-bit logical shift right instruction:

[<label>] lsrd
The operation is 0

[<comment>]

b7 ----------------- b0 accumulator A

b7 ----------------- b0 accumulator B

The HCS12 has three rotate left instructions that operate on 9-bit operands.
[<label>] rol opr place [<label>] rola [<label>] rolb The operation is [<comment>] [<comment>] [<comment>] -- memory location opr is rotated left one -- accumulator A is rotated left one place -- accumulator B is rotated left one place C

b7 ----------------- b0

The HCS12 has three rotate right instructions that operate on 9-bit operands.
[<label>] ror opr [<comment>] place [<label>] rora [<comment>] [<label>] rorb [<comment>] The operation is -- memory location opr is rotated right one

-- accumulator A is rotated right one place -- accumulator B is rotated right one place

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. accumulator A Solution:
1 C flag 0 0 0 1 0 1 0 1 0

Original value [A] = 10010101 C=1

New value [A] = 00101010 C=1

Figure 2.11b Execution result of the ASLA instruction

Figure 2.11a Operation of the ASLA instruction

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:
1 memory location $1000 1 1 1 1 0 1 1 0 1 1 1 0 1 1 0 1 C flag

Original value [$1000] = 11101101 C =0

New value [$1000] = 11110110 C =1

Figure 2.12a Operation of the ASR $1000 instruction

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: 1 1 1 0 0 1 1 1
memory location $800 0 0 1 1 1 0 0 1 1 1 C flag

Original value

New value

[$800] = 11100111 [$800] = 01110011 C=1 C=1 Figure 2.13b Execution result of LSR $800

Figure 2.13a Operation of the LSR $800 instruction

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 1 1 1 1 0 1 1 C flag accumulator B 0 1 1 1 1 0 1 1 1

Original value [B] = 10111101 C=1

New value [B] = 01111011 C=1

Figure 2.14a Operation of the instruction ROLB

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:

0 C flag

accumulator A

Figure 2.15a Operation of the instruction rora

Original value [A] = 10111110 C=1

New value [A] = 11011111 C=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 db org zero_cnt rmb lp_cnt rmb org clr ldaa staa ldd loop lsrd bcs inc chkend dec bne forever bra end $1000 $23,$55 $1005 1 1 $1500 zero_cnt #16 lp_cnt $1000 ; test data

; initialize the 0s count to 0

chkend zero_cnt lp_cnt loop forever

; place the number in D ; shift the lsb of D to the C flag ; is the C flag a 0? ; increment 1s count if the lsb is a 1 ; check to see if D is already 0

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.

Shift a Multi-byte Number (3 of 3)

Example 2.24 Write a program to shift the 32-bit number stored at $820-$823 to the right four places. Solution:
ldab ldx lsr ror ror ror dbne end #4 ; set up the loop count #$820 ; use X as the pointer to the left most byte 0,X 1,X 2,X 3,X b,again

again

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.
Table 2.8 Summary of Booleran logic instructions Mnemonic ANDA <opr> ANDB <opr> ANDCC <opr> EORA <opr> EORB <opr> ORAA <opr> ORAB <opr> ORCC <opr> CLC CLI CLV COM <opr> COMA COMB NEG <opr> NEGA NEGB Function AND A with memory AND B with memory AND CCR with memory (clear CCR bits) Exclusive OR A with memroy Exclusive OR B with memory OR A with memory OR B with memory OR CCR with memory Clear C bit in CCR Clear I bit in CCR Clear V bit in CCR One's complement memory One's complement A One's complement B Two's complement memory Two's complement A Two'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) C0 I0 V 0 M $FF - (M) A $FF - (A) B $FF - (B) M $00 - (M) A $00 - (A) B $00 - (B)

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.

Program Execution Time (2 of 2)

loop psha pula psha pula psha pula psha pula psha pula psha pula psha pula nop nop dbne x,loop ; 2 E cycles ; 3 E cycles

; 1 E cycle ; 1 E cycle ; 3 E cycles

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 cycles pula ; 3 E cycles psha pula psha pula psha pula psha pula psha pula psha pula nop ; 1 E cycle nop ; 1 E cycle dbne x,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.

ldab out_loop ldx in_loop psha pula psha pula psha pula psha pula psha pula psha pula psha pula nop nop dbne dbne

#100 #20000 ; 2 E cycles ; 3 E cycles

; 1 E cycle ; 1 E cycle x,in_loop ; 3 E cycles b,out_loop ; 3 E cycles