Microprocessor Fundamentals. Topic 8 Binary Addition

Transcription

1 Microprocessor Fundamentals Topic 8 Binary Addition

2 Objectives Examine several assembler directives:.dseg /.eseg /.cseg.db.byte Use indirect addressing X register (r26 and r27) Post-increment Store results in Data Memory Look at alternate approaches Discuss potential problems 1/4/2010 2

3 Assembler Directives Assembler directives are: Commands to the assembler (AVR Studio) not the microcontroller Most begin with. Have used several already:.device.def.include.list /.nolist 1/4/2010 3

4 Assembler Directives New directives are:.db (define constant byte) Allows us to place a list of data in the source file Must be used with.cseg or.eseg 1.BYTE.cseg: Code segment program memory.eseg: EEPROM segment.dseg: Data segment Allows us to reserve (and label) data space for storing data.org (origin) Allows us to specify where we want code or data to be placed in memory [1] AVR Studio Assembler Help File, but I could only get it to work in the simulator with.dseg and 1/4/2010 then placing the data in simulated memory manually needs to be tested on the development board 4

5 Example: Directives placed in a binary addition program ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 In this example, data is a label pointing to the data list, and result is pointing to 2 bytes of reserved memory space for the result Note: the list of data is in decimal, the assembler will convert the numbers to hex 1/4/2010 5

6 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 LEDs Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh The results will be output to LEDs through PortB, so PortB had to be setup as all outputs with initial low outputs to turn off the = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/2010 6

7 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 address byte of X, and r27 holds the high byte ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh X is being initialized to point to the data. R26 holds the low = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/2010 7

8 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = The label data refers to the address of where the data is stored ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/2010 8

9 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh r17 (named Sum ) will hold the sum of all the numbers, and so it is cleared as its initialization = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/2010 9

10 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh Addend is actually r16. Here, r16 is being loaded with the next (or 1 st ) number to be added to the sum (r17). X points to the data by containing the address of the 1 st data element. = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/

11 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number FF (or 255 decimal) is being used as a marker for the end of data. Blank (or empty) memory locations are shown as FF. If the data loaded in the previous instruction is FF, then the program has reached the end of the list of data and it is time to cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend display ; add numbers the sum. jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/

12 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 So, if the cpi instruction sets the Z bit (the two values were equal), the program should branch to the label Str 1/4/

13 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 add ; initialize it to the current Sum register sum Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 If the number we retrieved is not FF, then it must be data, so 1/4/

14 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 Branch to the label Next to get the next number in the list 1/4/

15 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 If the last number to be retrieved from memory was FF (the marker for the end of data), then the program will branch here and store the data at the address labeled result 1/4/

16 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend the ; LEDs. add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 After the sum is stored, it will be sent out PortB, which lights 1/4/

17 Add Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi Addend,255 ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 The relative jump (rjmp) to itself, effectively halts the program. Actually, the AVR continuously jumps back to this instruction. 1/4/

18 Assembly: If you have not done before now you need to set an assembler option so that a list file is created when the program is assembled Choose Assembler Options from the Project menu

19 Assembly: Make sure that Create List File is checked Click the [OK] button

20 Assembly: Then assemble the file. The program assembled OK It used 34 bytes of the Code Segment (Program Space) It used 12 bytes of the Data Segment: 10 bytes of data to add and two bytes to store the result 1/4/

21 Assembly: The list file has a lst extension. It shows the addresses as well as the op codes for all instructions. At the end of the file: Assembly complete, 0 errors, 0 warnings is shown 1/4/

22 Simulation: The simulator will not load the data into simulated Data Space. You must insert the data manually 1/4/

23 Simulation: The data has been entered. Note also that X has the address $0100. Only the label data was specified, but nothing in the data section specifies $ /4/

24 Simulation: This happens because $0100 is the beginning of Data Space (SRAM) on the ATmega128. The assembler knows this (we specified an ATmega128) and so starts placing data at $ /4/

25 Simulation: The ld Addend,X+ has just been executed 2. The lower byte of X (r26) was incremented (X+: Post-Increment) 3. The data from $0100, the 05 (see note 4) was loaded into r16 (Addend) 5. None of these instructions have affected the status register 1/4/

26 Simulation: The cpi Addend,255 was executed. This instruction compares the current contents of r16 (05) to FF (decimal 255). It compares by subtracting 255 from 5 2. The compare (5 255) or ( ) sets H and C. The Z bit is not set (Z=0) so.. 1/4/

27 Simulation: The program falls through to the add instruction and. 1/4/

28 Simulation: adds the 05 (in Addend) to the 0 (in Sum) and gets a result in Sum (r17) of 05. This result clears all the bits in the status register. 1/4/

29 Simulation: At this point, all the numbers have been added. The result ($EC) is in r17 and the marker ($FF) has been loaded into r16. 1/4/

30 Simulation: The cpi instruction sets the Z bit because FF-FF = 0. Now that the Z bit is set, the program will branch to Str: 1/4/

31 Simulation: The branch was taken and the results were stored in $010A 1/4/

32 Simulation: And then the results ($EC) were output to PortB 1/4/

33 Alternative Program: ; Declarations.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: number of numbers in this case 10. ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi r26,0x0a ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 You could also write the program so that it just adds the correct To do this, compare the lower byte of the X register to 0x0A to see when the program has added 10 numbers. 1/4/

34 Problem: ; Declarations There is still a problem with this program. Do you know what it is?.device ATmega128.def Addend = r16 ;name registers.def Sum = r17 Init: ldi r18,0b ;setup outputs on PortB for results out DDRB, r18 ldi r18,0b ;set initial values for outputs out PortB, r18 ; turn them all off ldi r26,low(data) ;get low byte of address"result" and put it in Zlow ldi r27,high(data) ;get high byte of address"result" and put it in Zhigh = ;Start Program Start: ldi Sum,0 ; initialize Sum register Next: ld Addend,X+ ; get next number cpi r26,0x0a ; see if this is the "end marker" (FF) breq Str ; send sum to LEDs add Sum,Addend ; add numbers jmp Next ; get next number Str: sts result,sum out PortB,Sum ; sends results to Port B and LEDs Stop: rjmp Stop ====== ;Data.dseg data:.db 5, 27, 31, 92, 7, 40, 1, 8, 13, 12 result:.byte 2 1/4/

35 Problem: 10 numbers are added (whether you end the program by a count or by a marker) The largest number that can be stored in any address is $FF The program should be written to be able to handle any data set If all the numbers were $FF, then the result would have been: $9F6 This program was only concerned with the lower byte If all the data had been $FF, this program s results would have shown: $F6

36 Summary In this topic we: Examined several assembler directives:.dseg /.eseg /.cseg.db.byte Used indirect addressing X register (r26 and r27) Post-increment Stored results in Data Memory Looked at an alternate approach Discussed potential problems 1/4/