Chapter 2: HCS12 Assembly Programming. EE383: Introduction to Embedded Systems University of Kentucky. Samir Rawashdeh

Transcription

1 Chapter 2: HCS12 Assembly Programming EE383: Introduction to Embedded Systems University of Kentucky Samir Rawashdeh With slides based on material by H. Huang Delmar Cengage Learning 1

2 Three Sections of a HCS12/MC9S12 Assembly Program 1. Assembler Directives - Define data and symbol - Reserve and initialize memory locations - Set assembler and linking condition - Specify output format - Specifies the end of a program. 2. Assembly Language Instructions - HCS12/MC9S12 instructions 3. Comments - Explain the function of a single or a group of instructions

3 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

4 Fields of a HCS12 Instruction 1. 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 : 2. Operation field - Contains the mnemonic of a machine instruction or an assembler directive - 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 - Any line starts with an * or ; is a comment - Separated from the operand and operation field for at least one space - Optional

5 Assembler Directives 1. end - ends a program to be processed by an assembler - any statement following the end directive is ignored 2. 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.

6 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, org $1000 vec_tab dc.w $1234, $5620

7 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. - For example, msg fcc Please enter 1, 2 or 3:

8 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. - For example, buffer ds 100 reserves 100 bytes

9 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. - For 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 one s program more readable. - Examples arr_cnt equ 100 oc_cnt equ 50

10 Macro - A name assigned to a group of instructions - Use macro and endm to define a macro. - Example of macro sumof3 macro ldaa adda adda endm 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

11 Software Development Process 1 Problem definition: Identify what should be done 2 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 the overall plan is to use flowchart. 3 Programming. Convert the algorithm or flowchart into programs. 4 Program Testing. 5 Program maintenance.

12 Symbols of Flowchart Terminal A Process Subroutine Input or output Decision no B off-page connector yes A on-page connector Figure 2.1 Flowchart symbols used in this book

13 Programs to do simple arithmetic 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 $1100 A org $1500 ldaa $1000 adda $1001 adda $1002 staa $1100 end

14 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 $1100 end

15 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

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

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

18 Multiplication and Division

19 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 $1000 ldy $1002 emul sty $1100 std $1102 Example 2.11 Write an instruction sequence to divide the signed 16-bit number stored at $1020-$1021 into the 16-bit signed number stored at $1005-$1006 and store the quotient and remainder at $1100 and $1102, respectively. Solution: ldd $1005 ldx $1020 idivs stx $1100 ; store the quotient std $1102 ; store the remainder

20 Illustration of 32-bit by 32-bit Multiplication - Two 32-bit numbers M and N are divided into two 16-bit halves M = M H M L N = N H N L

21 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 a 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.

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

23 idiv adcb #$30 stab 3,Y ; save the second to least significant digit xgdx ldx #10 idiv addb #$30 stab 2,Y ; save the middle digit xgdx ldx #10 idiv addb #$30 stab 1,Y ; save the second most significant digit xgdx addb #$30 stab 0,Y ; save the most significant digit end

24 ASCII Table

25 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.

26

27 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

28

29 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.

30 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).

31 Implementation of Looping Constructs for I = n1 to n2 do S n1 equ xx ; starting index n2 equ yy ; ending index i ds.b 1 ; loop index variable movb #n1,i ; initialize i to n1 loopf ldaa i ; check index i cmpa #n2 bgt next ; if i is greater than n2, exit the loop ; performs loop operations ; inc i ; increment loop index bra loopf next

32 for i = n2 downto n1 do S n1 equ xx ; starting index n2 equ yy ; ending index i ds.b 1 ; loop index variable movb #n2,i ; initialize i to n2 loopf ldaa i ; check index i cmpa #n1 blt next ; if i is less than n1, exit the loop ; perform loop operations ; dec i ; increment loop index bra loopf next

33 While loop Loop terminating condition is checked at the start of the loop In the following example, icount == 0 is the condition to be check. The update of icount is done by an interrupt service routine (not shown below). N equ xx icount ds.b 1 movb #N,icount wloop ldaa #0 cmpa icount beq next bra wloop next

34 Repeat S until C Often used when a certain operation need to be performed a fixed number of times The template of this looping construct is as follows: N equ xx ldy #N ; Y is used as the loop counter loopr ; perform the desired operations ; dbne Y,loopr ; decrement the loop counter and decide whether to ; to continue

35 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 equ 20 org $1000 sum ds.b 2 i ds.b 1 org $1500 movb #0,i movw #0,sum ; sum 0 loop ldab i cmpb #N ; is i = N? beq done ldx #array abx ldab 0,X ; sum sum + array[i] ldy sum ; aby ; sty sum ; inc i bra loop done swi

36 array 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:

37 N equ 20 org $1000 max_val ds.b 1 org $1500 ldaa array ; set array[0] as the temporary max max staa 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_val cmpa 0,x bge chk_end ldaa 0,x staa max_val ; update the array max chk_end dex ; move to the next array element dbne b,loop ; finish all the comparison yet? forever bra forever array db 1,3,5,6,19,41,53,28,13,42,76,14 db 20,54,64,74,29,33,41,45 end

38 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 zeros.

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

40 Instructions for Variable Initialization 1. [<label>] CLR opr [<comment>] where opr is specified using the extended or index addressing modes. The specified memory location is cleared. 2. [<label>] CLRA [<comment>] Accumulator A is cleared to 0 3. [<label>] CLRB [<comment>] Accumulator B is cleared to 0

41 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>] -- 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 b b0 0

42 The HCS12 has one 16-bit arithmetic shift left instruction: [<label>] asld [<comment>] The operation is 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 C b b0 b b0 0 accumulator A accumulator B b b0 C

43 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 b b0 0 The HCS12 has one 16-bit logical shift left instruction: [<label>] lsld [<comment>] The operation is C b b0 b b0 0 accumulator A accumulator B

44 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 is 0 b b0 C The HCS12 has one 16-bit logical shift right instruction: [<label>] lsrd [<comment>] The operation is 0 b b0 b b0 accumulator A accumulator B C

45 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 is b b0 C 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 b b0

46 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: accumulator A C flag Original value [A] = C = 1 New value [A] = C = 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: memory location $ C flag Original value [$1000] = C = 0 New value [$1000] = C = Figure 2.12b Result of the asr $1000 instruction Figure 2.12a Operation of the ASR $1000 instruction

47 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:

48 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:

49 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 $1000 db $23,$55 ; test data org $1005 zero_cnt rmb 1 lp_cnt rmb 1 org $1500 clr zero_cnt ; initialize the 0s count to 0 ldaa #16 staa lp_cnt ldd $1000 ; place the number in D loop lsrd ; shift the lsb of D to the C flag bcs 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 0 bne loop forever bra forever end

50 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 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.

51 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 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.

52 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 count ldx #$820 ; use X as the pointer to the left most byte again lsr 0,X ror 1,X ror 2,X ror 3,X dbne b,again end

53 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.

54 Program Execution Time 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: 1. Select a sequence of instructions that takes a certain amount of time to execute. 2. 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 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.

55 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

56 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 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

57 From the CPU12 Reference Manual: PSHA takes 2 E-cycles to execute

58 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 #100 out_loop ldx #20000 in_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,in_loop ; 3 E cycles dbne b,out_loop ; 3 E cycles