H. Huang Transparency No.2-1 The 68HC11 Microcontroller Chapter 2: 68HC11 Assembly Programming The 68HC11 Microcontroller

H. Huang Transparency No.2-2 The 68HC11 Microcontroller Assembly Program (1) * Data storage declaration section (2) ORG $00 (3) iRMB 1; variable i (4) jRMB 1; variable j (5) kRMB 1; variable k (6) * program instruction section (7) startORG $C000; starting address of program (8) LDAA #75 (9)STAA i; initialize i to 75 (10)LDAA #10 (11)STAA j; initialize j to 10 (12)ADDA i; compute i + j (13)SUBA #6; compute i + j -6 (14)STAA k; store i + j - 6 to k (15)END

H. Huang Transparency No.2-3 The 68HC11 Microcontroller Global View of a 68HC11 Assembly Program 1. Assembler Directives - define data and symbol -reserve and initialize memory locations - set assembler and linking condition - specify output format - etc. 2. Assembly Language Instructions 3. END directive - last statement of a program - any statement after END will be ignored 4. Comments - explain the function of a single or a group of instructions

H. Huang Transparency No.2-4 The 68HC11 Microcontroller Fields of a 68HC11 Instruction 1. Label field -is optional - starts with a letter and followed by letters, digits, or special symbols (_ or.) -can start from any column if ended with “:” (not true for Motorola freeware as11) -must start from column 1 if not ended with “:” 2.Operation field -contains the mnemonic of a machine instruction or a directive -is separated from the label by at least one space 3.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 4.Comment field -a whole line comment starts with a * -is separated from the operand and operation field for at least one space

H. Huang Transparency No.2-5 The 68HC11 Microcontroller Identify the Four Fields of an Instruction Example 2.3 loopADDA #$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

H. Huang Transparency No.2-6 The 68HC11 Microcontroller Assembler Directives -- a sample 1. END -ends a program to be processed by an assembler -any statement following the END directive is ignored -not supported by the Motorola freeware as11 2.ORG -sets a new value for the location counter of the assembler -tells the assembler where to put the next byte it generates after the ORG directive The sequence ORG $C000 LDAB #$FF will put the opcode byte for the instruction LDAB #$FF at location $C RMB-- reserve memory bytes -reserve memory bytes without initialization -syntax is [ ] RMB [ ] The statement bufferRMB 100 allocates 100 bytes for data and can be referred to by the label “buffer”.

H. Huang Transparency No.2-7 The 68HC11 Microcontroller BSZ -- block storage of zeros -causes the assembler to allocate a block of bytes that are initialized to zeros -syntax is [ ]BSZ [ ] The statement bufferBSZ 80 reserves a block of 80 bytes and their value are initialized to 0. FCB -- form constant byte -reserves as many bytes as the number of arguments in the directive -each argument specifies the initial value of the corresponding byte -syntax is [ ] FCB [ ][,,..., ][ ] The statement ABCFCB$11,$22,$33 reserves three consecutive memory bytes and initializes their values to $11, $22, and $33.

H. Huang Transparency No.2-8 The 68HC11 Microcontroller FDB -- form double byte - reserves 2 bytes for each argument of the directive - each argument specifies the initial value of the corresponding double bytes -syntax is [ ]FDB [ ][,,..., ] [comment>] The directive ABCFDB $11,$22,$33 will initialize 6 consecutive bytes in memory to $00 $11 $00 $22 $00 $33 FCC -- form constant character -generates ASCII code bytes for the letters in the arguments -syntax is [label]FCC “ “ [ ] The directive ALPHAFCC “DEF” will generate the values $44 $45 $46 in memory

H. Huang Transparency No.2-9 The 68HC11 Microcontroller DCB -- define constant block -reserve an area of memory and initialize each byte to the same constant value -syntax is [label]DCB, - not supported by the Motorola freeware as11 The directive spaceDCB 80,$20 will generate a line of 80 space characters. FILL -- fill a block of constant values -serve as the same purpose as does the DCB directive -syntax [ ] FILL, The directive onesFILL 1,40 will force the freeware assembler to fill each of the 40 memory locations with a 1.

H. Huang Transparency No.2-10 The 68HC11 Microcontroller EQU -- equate -allows the user to use a symbolic name in place of a number -syntax is EQU [ ] The directive ROM EQU$E000 tells the assembler that wherever ROM appears in the program, the value $E000 is to be substituted.

H. Huang Transparency No.2-11 The 68HC11 Microcontroller Terminal Process Input or output Decision Subroutine A B A Flowchart - is a form of program documentation - is a tool for developing program logic flow Symbols of Flowchart yes no On-page connector Off-page connector

H. Huang Transparency No.2-12 The 68HC11 Microcontroller Procedure of Using Computer in Solving the Problem start analyze the problem Express the solution to the problem using flowchart or other method Convert the flowchart into source code Compile or assemble to generate machine code Place the executable code in the computer Run the program and evaluate the result Is the result satisfactory? Refine the solution No Yes Stop

H. Huang Transparency No.2-13 The 68HC11 Microcontroller Programs to do simple arithmetic Example 2.4 Write a program to add the values of memory locations at $00, $01, and $02, and save the result at $03. LDAA $00 ; load the contents of memory location at $00 into A ADDA$01; add the contents of memory location at $01 to A ADDA$02; add the contents of memory location at $02 to A STAA $03; save the result at memory location at $03 Example 2.5 Write a program to subtract 6 from three 8-bit numbers stored at $00, $01, and $02 respectively. LDAA$00; load the first number into A SUBA #06; subtract 6 from the first number STAA $00; store the decremented value back to $00 LDAA$01; load the second number into A SUBA #06; subtract 6 from the second number STAA $01; store the decremented value back to $01 LDAA$02; load the third number into A SUBA#06; subtract 6 from the third number STAA$02; store the decremented value back to $02

H. Huang Transparency No.2-14 The 68HC11 Microcontroller 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 Example 2.6 Write a program to add the 3-byte numbers stored at $00-$02 and $03-$05 and save the result at $06-$08. Solution: The addition starts from the least significant byte. LDAA$02; add the LSBs ADDA$05; “ STAA$08; “ LDAA$01; add the middle bytes ADCA$04; “ STAA$07; “ LDAA$00; add the MSBs ADCA$03; “ STAA$06; “

H. Huang Transparency No.2-15 The 68HC11 Microcontroller Example 2.7 Write a program to subtract the 3-byte number stored at $03-$05 from the 3-byte number stored at $00-$02 and save the result at $10-$12. Solution: The subtraction starts from the LSBs. LDAA$02; subtract the LSBs SUBA$05; “ STAA$12; “ LDAA$01; subtract the middle bytes SUBA$04; “ STAA$11; “ LDAA$00; subtract the MSBs SUBA$03; “ STAA$10; “

H. Huang Transparency No.2-16 The 68HC11 Microcontroller 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$00 ADDA$01 DAA STAA$02 adds the BCD numbers stored at $00 and $01 and saves the sum at $02.

H. Huang Transparency No.2-17 The 68HC11 Microcontroller Program Loops Types of program loops: finite and infinite loops Looping mechanisms: 1.DO statement S forever 2.FOR i = n1 to n2 DO statement S or FOR i = n2 downto n1 DO statement S 3.WHILE C DO statement S 4.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.

H. Huang Transparency No.2-18 The 68HC11 Microcontroller Condition Code Register S XHINZVC -C:carry flag -V: overflow flag -Z:zero flag -N:negative flag -H:half carry flag Conditional Branch Instruction [ ]Bccrel[ ] where cc is a condition code listed in Table 2.1. Unconditional Branch Instruction [ ]BRA rel[ ]

H. Huang Transparency No.2-19 The 68HC11 Microcontroller Table 2.1 Branch Condition Codes Condition code Meaning CC carry clear CS carry set EQ equal to 0 GE greater than or equal to 0 (signed comparison) GT greater than 0 (signed comparison) HI higher (unsigned comparison) HS higher or same (unsigned comparison) LE less than or equal to 0 LO lower (unsigned comparison) LS lower or same (unsigned comparison) LT less than 0 (signed comparison) MI minus (signed comparison) NE not equal to 0 PL plus (signed comparison) VC overflow bit clear VS overflow bit set

H. Huang Transparency No.2-20 The 68HC11 Microcontroller Conditional Branch Instructions that check only one condition flag -C flag:BCC branch if C flag is 0 BCS branch if C flag is 1 BLO branch if C flag is 1 BHSbranch if C flag is 0 -Z flagBEQbranch if Z flag is 1 BNEbranch if Z flag is 0 -N flagBPLbranch if N flag is 0 BMIbranch if N flag is 1 -V flagBVSbranch if V flag is 1 BVCbranch if V flag is 0 Conditional Branch Instructions that check more than one condition flag -BGEbranch if (N  V) = 0 -BGTbranch if (Z + (N  V)) = 0 -BHIbranch if (C + Z) = 0 -BLEbranch if (Z + (N  V)) = 1 -BLSbranch if (C + Z) = 1 -BLTbranch if (N  V) = 1

H. Huang Transparency No.2-21 The 68HC11 Microcontroller Decrementing and Incrementing Instructions -DECA:A  [A] - 1 -DECB:B  [B] - 1 -DEC opr:mem[opr]  [mem[opr]] - 1 -DES:SP  [SP] - 1 -DEX:X  [X] - 1 -DEY:Y  [Y] - 1 -INCA:A  A   INCB:B  B]  1 -INC opr:mem[opr]  [mem[opr]] + 1 -INS:SP  [SP] + 1 -INX:X  [X] + 1 -INY:Y  [Y] + 1 Note 1. Incrementing and decrementing instructions can be used to update the loop indices. Note 2. The memory operand opr is specified in either extended or index addressing mode.

H. Huang Transparency No.2-22 The 68HC11 Microcontroller Example 2.15 Write a program to compute and save the sum at $00. Solution: Start i = 0 sum = 0 i = i + 1 sum = sum + i i = 20 ? Stop no yes * The following program use accumulator B as the loop index * i and A as the sum. Nequ 20 ldab #0 ; initialize loop index i to 0 ldaa #0; initialize sum to 0 againincb; increment i aba; add i to sum cmpb #20 ; compare i with the upper limit bne again; continue if i is less than 20 staa $00; save the sum end

H. Huang Transparency No.2-23 The 68HC11 Microcontroller Example 2.16 Write a program to find the largest number from an array of 20 8-bit numbers. The array is stored at $00-$13. Save the result at $20. Solution: Start array max  array [0] i  1 array max < array [i] ? i = array count - 1? Stop i  i + 1 array max  array [i] yes no yes

H. Huang Transparency No.2-24 The 68HC11 Microcontroller * The following program uses A to hold the temporary array max and uses B * as the loop index. Nequ 20; array count org $00 arrayfcb....; array ldaa array; set array[0] as the temporary array max ldab #1; initialize loop index to 1 loopldx #array; point X to array[0] abx; compute the address of array[i] cmpa 0,X; compare temp. array max to the next element bhs chkend; do we need to update the temporary array max? ldaa 0,X; update the temporary array max chkendcmpb #N-1; compare loop index with loop limit beq exit; is the whole array checked yet? incb; increment loop index bra loop exitstaa $20; save the array max end

H. Huang Transparency No.2-25 The 68HC11 Microcontroller Compare Instructions -are executed to set the condition flags of the CCR register -are often used to implement the program loop Instruction format [ ] CBA[ ]compare A to B [ ] CMPA opr[ ]compare A to a memory location or value [ ] CMPB opr[ ]compare B to a memory location or value [ ] CPD opr[ ]compare D to a memory location or value [ ] CPX opr[ ]compare X to a memory location or value [ ] CPY opr[ ]compare Y to a memory location or value [ ] TST opr[ ]test a memory location for negative or zero [ ] TSTA[ ]test A for negative or zero [ ] TSTB[ ]test B for negative or zero Table HC11 Compare Instructions opr is specified in one of the following addressing modes: - EXT - INDX - INDY - IMM(not applicable to “TST opr”) - DIR(not applicable to “TST opr”)

H. Huang Transparency No.2-26 The 68HC11 Microcontroller Special Conditional Branch Instructions [ ] BRCLR (opr) (msk) (rel) [ ] [ ] BRSET (opr) (msk) (rel) [ ] where oprspecifies the memory location to be checked and must be specified using either the direct or index addressing mode. mskis 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. relis the branch offset and is specified in the relative mode. For example, the sequence ldx #$1000 herebrclr $30,X % here ldaa $31,X will force the 68HC11 continue to execute the second instruction until the bit 7 is set to 1.

H. Huang Transparency No.2-27 The 68HC11 Microcontroller Example 2.17 Write a program to compute the sum of the odd numbers in an array with 20 8-bit elements. The array is stored at $00-$13. Save the sum at $20-$21. Solution: Start sum  0 ptr  0 bit 0 of mem[ptr] = 0? sum  sum + [mem[ptr]] no ptr = $13? ptr  ptr + 1 Stop no yes

H. Huang Transparency No.2-28 The 68HC11 Microcontroller * The index register X is used as the pointer to the array element. Nequ$13 org$20 sumrmb2 org$C000 ldaa#$00 staasum; initialize sum to 0 staasum+1;“ ldx#$00; point X to array[0] loopbrclr0,X $01 chkend ; is it an odd number? lddsum; add the odd number to the sum addb0,X; “ adca#0;“ stdsum;“ chkendcpx#N; compare the pointer to the address of the last element bhsexit; is this the end? inx braloop; not yet done, continue exitend

H. Huang Transparency No.2-29 The 68HC11 Microcontroller Instructions for Variable Initialization 1.[ ] CLRopr [ ] where opr is specified using the extended or index addressing mode. The specified memory location is cleared. 2.[ ] CLRA[ ] Accumulator A is cleared to 0 3.[ ] CLRB[ ] Accumulator B is cleared to 0

H. Huang Transparency No.2-30 The 68HC11 Microcontroller Shift and Rotate Instructions The 68HC11 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 mode. There are three 8-bit arithmetic shift left instructions: [ ]ASL opr [ ]-- memory location opr is shifted left one place [ ]ASLA[ ]-- accumulator A is shifted left one place [ ]ASLB[ ]-- accumulator B is shifted left one place The operation is C 0 b b0

H. Huang Transparency No.2-31 The 68HC11 Microcontroller The 68HC11 has arithmetic shift right instructions that apply to a memory location and accumulators A and B. [ ]ASR opr[ ]-- memory location opr is shifted right one place [ ]ASRA[ ]-- accumulator A is shifted right one place [ ]ASRB[ ]-- accumulator B is shifted right one place The operation is Cb b0 The 68HC11 has one 16-bit arithmetic shift left instruction: [ ]ASLD[ ] The operation is C 0 b b0 accumulator A accumulator B

H. Huang Transparency No.2-32 The 68HC11 Microcontroller The 68HC11 has logical shift left instructions that apply to a memory location and accumulators A and B. [ ]LSL opr[ ]-- memory location opr is shifted left one place [ ]LSLA[ ]-- accumulator A is shifted left one place [ ]LSLB[ ]-- accumulator B is shifted left one place The operation is Cb b0 0 The 68HC11 has one 16-bit logical shift left instruction: [ ]LSLD[ ] The operation is C 0 b b0 accumulator A accumulator B

H. Huang Transparency No.2-33 The 68HC11 Microcontroller The 68HC11 has three logical shift right instructions that apply to 8-bit operands. [ ]LSR opr[ ]-- memory location opr is shifted right one place [ ]LSRA[ ]-- accumulator A is shifted right one place [ ]LSRB[ ]-- accumulator B is shifted right one place The operation is Cb b0 0 The 68HC11 has one 16-bit logical shift right instruction: [ ]LSRD[ ] The operation is C 0 b b0 accumulator A accumulator B

H. Huang Transparency No.2-34 The 68HC11 Microcontroller The 68HC11 has three rotate left instructions that operate on 9-bit operands. [ ]ROL opr[ ]-- memory location opr is rotated left one place [ ]ROLA[ ]-- accumulator A is rotated left one place [ ]ROLB[ ]-- accumulator B is rotated left one place The operation is Cb b0 The 68HC11 has three rotate right instructions that operate on 9-bit operands. [ ]ROR opr[ ]-- memory location opr is rotated right one place [ ]RORA[ ]-- accumulator A is rotated right one place [ ]RORB[ ]-- accumulator B is rotated right one place The operation is C b b0

H. Huang Transparency No.2-35 The 68HC11 Microcontroller Example 2.18 Suppose that [A] = $74 and C = 1. Compute the new values of A and C after the execution of the instruction ASLA. Solution: The operation is C A Result: [A] = % C = 0 Example 2.19 Suppose that [mem[$00]] = $F6 and C = 1. Compute the new values of mem[$00] and the C flag after the execution of the instruction ASR $00. Solution: The operation is mem[$00] C 0 Result: [mem[$00]] = % C = 0

H. Huang Transparency No.2-36 The 68HC11 Microcontroller Example 2.20 Suppose that [mem[$00]] = $F6 and C = 1. Compute the new contents of mem[$00] and the C flag after the execution of the instruction LSR $00. Solution: The operation is mem[$00] C 0 Result: [mem[$00]] = % C = 0 0 Example 2.21 Suppose that [B] = $BE and C = 1. Compute the new values of B after the execution of the instruction ROLB. Solution: The operation is B C 1 1 Result: [B] = % C = 1

H. Huang Transparency No.2-37 The 68HC11 Microcontroller Example 2.22 Suppose that [B] = $BE and C = 1. Compute the new values of mem[$00] after the execution of the instruction RORB. Solution: The operation is C B 0 1 Result: [B] = % C = 0

H. Huang Transparency No.2-38 The 68HC11 Microcontroller Example 2.23 Write a program to count the number of 1s in the 16-bit number stored at $00-$01 and save the result in $02. Solution: * The 16-bit number is shifted to the right up to 16 time or until the shifted value becomes 0. * If the bit shifted out is a 1 then increment the 1s count by 1. org$C000 ldaa#$00; initialize the 1s count to 0 staa$02;“ ldd$00; place the number in D looplsrd; shift the lsb of D to the C flag bcctestzero; is the C flag a 0? inc$02; increment 1s count if the lsb is a 1 testzerocpd#0; check to see if D is already 0 bneloop end

H. Huang Transparency No.2-39 The 68HC11 Microcontroller Shift a multi-byte number For shifting right 1.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. 2.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.

H. Huang Transparency No.2-40 The 68HC11 Microcontroller For shifting left 1.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. 2.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 leftt 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.

H. Huang Transparency No.2-41 The 68HC11 Microcontroller Example 2.24 Write a program to shift the 32-bit number stored at $20-$23 to the right four places. Solution: ldab#4; set up the loop count ldx#$20; use X as the pointer to the left most byte againlsr0,X ror1,X ror2,X ror3,X decb bneagain end

H. Huang Transparency No.2-42 The 68HC11 Microcontroller Program Execution Time An easy way to create a delay is to use program loops. Use the instructions in Table 2.3 as an example. Instruction Execution time (E clock cycles) BNE 3 DECB 2 DEX 3 LDAB 2 LDX 3 NOP2 Table 2.3 Execution times of a sample of instructions The following instruction sequence takes 5  s to execute for 2 MHz E clock signal. againnop; 2 E cycles nop; 2 E cycles dex; 3 E cycles bne again; 3 E cycles

H. Huang Transparency No.2-43 The 68HC11 Microcontroller 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 times. The following instruction sequence creates a delay of 100 ms. ldx#20000 againnop nop dex bneagain Longer delays can be created by using nested program loops. Example 2.26 Write a program to create a 10-second delay. Solution: A 10-second delay can be created by repeating the loop in example times. ldab#100 outerldx#20000 innernop nop dex bneinner decb bneouter