Файл: Beginers introduction to the Assebly Language of ATMEL-AVR Microprocessors (Gerhard Schmidt,2003, англ).pdf

LDI ZH,HIGH(2*Adress)

LDI ZL,LOW(2*Adress)

LPM

Following this command the adress must be incremented to point to the next byte in program memory. As this is used very often a special pointer incrementation command has been defined to do this:

ADIW ZL,1 LPM

ADIW means ADd Immediate Word and a maximum of 63 can be added this way. Note that the assembler expects the lower of the pointer register pair ZL as first parameter. This is somewhat confusing as addition is done as 16-bit- operation.

The complement command, subtracting a constant value of between 0 and 63 from a 16-bit pointer register is named SBIW, Subtract Immediate Word. (SuBtract Immediate Word). ADIW and SBIW are possible for the pointer register pairs X, Y and Z and for the register pair R25:R24, that does not have an extra name and does not allow access to SRAM or program memory locations. R25:R24 is ideal for handling 16-bit values.

How to insert that table of values in the program memory? This is done with the assembler directives .DB and .DW. With that you can insert bytewise or wordwise lists of values. Bytewise organised lists look like this:

.DB 123,45,67,89 ; a list of four bytes

.DB "This is a text. " ; a list of byte characters

You should always place an even number of bytes on each single line. Otherwise the assembler will add a zero byte at the end, which might be unwanted.

The similiar list of words looks like this:

.DW 12345,6789 ; a list of two words

Instead of constants you can also place labels (jump targets) on that list, like that:

Label1:

[ ... here are some commands ... ] Label2:

[ ... here are some more commands ... ] Table:

.DW Label1,Label2 ; a wordwise list of labels

Labels ALWAYS start in column 1!. Note that reading the labels with LPM first yields the lower byte of the word.

A very special application for the pointer registers is the access to the registers themselves. The registers are located in the first 32 bytes of the chip's adress space (at adress 0x0000 to 0x001F). This access is only meaningful if you have to copy the register's content to SRAM or EEPROM or read these values from there back into the registers. More common for the use of pointers is the access to tables with fixed values in the program memory space. Here is, as an example, a table with 10 different 16-bit values, where the fifth table value is read to R25:R24:

MyTable:

.DW 0x1234,0x2345,0x3456,0x4568,0x5678 ; The table values, wordwise

.DW 0x6789,0x789A,0x89AB,0x9ABC,0xABCD ; organised Read5: LDI ZH,HIGH(MyTable*2) ; Adress of table to pointer Z

LDI ZL,LOW(MyTable*2) ; multiplied by 2 for bytewise access ADIW ZL,10 ; Point to fifth value in table

LPM ; Read least significant byte from program memory MOV R24,R0 ; Copy LSB to 16-bit register

ADIW ZL,1 ; Point to MSB in program memory LPM ; Read MSB of table value

MOV R25,R0 ; Copy MSB to 16-bit register

This is only an example. You can calculate the table adress in Z from some input value, leading to the respective table values. Tables can be organised byteor character-wise, too.

Recommendation for the use of registers

•Define names for registers with the .DEF directive, never use them with their direct name Rx.

•If you need pointer access reserve R26 to R31 for that purpose.

•16-bit-counter are best located R25:R24.

•If you need to read from the program memory, e.g. fixed tables, reserve Z (R31:R30) and R0 for that purpose.

•If you plan to have access to single bits within certain registers (e.g. for testing flags), use R16 to R23 for that purpose.

LDI ZL,LOW(PORTB+32)

LD MyPreferredRegister,Z

That only makes sense in certain cases, but it is possible. It is the reason why the first address location of the SRAM is always 0x60.

Details of relevant ports in the AVR

The following table holds the most used ports. Not all ports are listed here, some of the MEGA and AT90S4434/8535 types are skipped. If in doubt see the original reference.

The status register as the most used port

By far the most often used port is the status register with its 8 bits. Usually access to this port is only by automatic setting and clearing bits by the CPU or accumulator, some access is by reading or branching on certain bits in that port, in a few cases it is possible to manipulate these bits directly (using the assembler command SEx or CLx, where x is the bit abbreviation). Most of these bits are set or cleared by the accumulator through bit-test, compareor calculation-operations. The following list has all assembler commands that set or clear status bits depending on the result of the execution.

Port details

Port details of the most common ports are shown in an extra table (see annex).

STS MyPreferredStorageCell, R1

Yes, it isn't shorter, but easier to remember. Use whatever name that you find to be convenient.

Another kind of access to SRAM is the use of pointers. You need two registers for that purpose, that hold the 16-bit address of the location. As we learned in the Pointer-Register-Division pointer registers are the pairs X (XH:XL, R27:R26), Y (YH:YL, R29:R28) and Z (ZH:ZL, R31:R30). They allow access to the location they point to directly (e.g. with ST X, R1), after prior decrementing the address by one (e.g. ST -X, R1) or with subsequent incrementation of the address (e.g. ST X+, R1). A complete access to three cells in a row looks like this:

.EQU MyPreferredStorageCell = 0x0060

.DEF MyPreferredRegister = R1

.DEF AnotherRegister = R2

.DEF AndAnotherRegister = R3

LDI XH, HIGH(MyPreferredStorageCell)

LDI XL, LOW(MyPreferredStorageCell) LD MyPreferredRegister, X+

LD AnotherRegister, X+ LD AndAnotherRegister, X

Easy to operate, those pointers. And as easy as in other languages than assembler, that claim to be easier to learn.

The third construction is a little bit more exotic and only experienced programmers use this. Let's assume we very often in our program need to access three SRAM locations. Let's futher assume that we have a spare pointer register pair, so we can afford to use it exclusively for our purpose. If we would use the ST/LD instructions we always have to change the pointer if we access another location. Not very convenient.

To avoid this, and to confuse the beginner, the access with offset was invented. During that access the register value isn't changed. The address is calculated by temporarly adding the fixed offset. In the above example the access to location 0x0062 would look like this. First, the pointer register is set to our central location 0x0060:

.EQU MyPreferredStorageCell = 0x0060

.DEF MyPreferredRegister = R1

LDI YH, HIGH(MyPreferredStorageCell)

LDI YL, LOW(MyPreferredStorageCell)

Somewhere later in the program I'd like to access cell 0x0062:

STD Y+2, MyPreferredRegister

Note that 2 is not really added to Y, just temporarly. To confuse you further, this can only be done with the Y- and Z-register-pair, not with the X-pointer!

The corresponding instruction for reading from SRAM with an offset

LDD MyPreferredRegister, Y+2

is also possible.

That's it with the SRAM, but wait: the most relevant use as stack is still to be learned.

Use of SRAM as stack

The most common use of SRAM is its use as stack. The stack is a tower of wooden blocks. Each additional block goes onto the top of the tower, each recall of a value removes the upmost block from the tower. This structure is called Last-In-First-Out (LIFO) or easier: the last to go on top will be the first coming down.

Defining SRAM as stack

To use SRAM as stack requires the setting of the stack pointer first. The stack pointer is a 16-bit-pointer, accessable like a port. The double register is named SPH:SPL. SPH holds the most significant address byte, SPL the least significant. This is only true, if the AVR type has more than 256 byte SRAM. If not, SPH is undefined and must not and cannot be used. We assume we have more than 256 bytes in the following examples.

To construct the stack the stack pointer is loaded with the highest available SRAM address. (In our case the tower grows downwards, towards lower addresses!).

.DEF MyPreferredRegister = R16

LDI MyPreferredRegister, HIGH(RAMEND) ; Upper byte OUT SPH,MyPreferredRegister ; to stack pointer

LDI MyPreferredRegister, LOW(RAMEND) ; Lower byte OUT SPL,MyPreferredRegister ; to stack pointer