Given
var16: .dw VAL16
I want to do
lds zl, low_byte(var16)
lds zh, high_byte(var16)
I know I could load var16 and var16+1, but I'm wondering if there is some directive or somesuch, which I'm not seeing, that does that a bit more readably.
Of course you may feel that var16, var16+1 is perfectly readable. :)
Givenvar16: .dw VAL16I want to do
lds zl, low_byte(var16) lds zh, high_byte(var16)I know I could load var16 and var16+1, but I'm wondering if there is some directive or somesuch, which I'm not seeing, that does that a bit more readably.
Of course you may feel that var16, var16+1 is perfectly readable. :)
kk6gm wrote:Usually high_byte(var16) != low_byte(var16)+1 .Givenvar16: .dw VAL16I want to do
lds zl, low_byte(var16) lds zh, high_byte(var16)I know I could load var16 and var16+1, but I'm wondering if there is some directive or somesuch, which I'm not seeing, that does that a bit more readably.
Of course you may feel that var16, var16+1 is perfectly readable. :)
low_byte(var16)=var16 & 0xFF
high_byte(var16)=(var16>>8) & 0xFF
But var16 is a 16 bit value. var16 + 1 would give you the 16 bit value after var16.
But var16 is a 16 bit value. var16 + 1 would give you the 16 bit value after var16.
lds Z,var16 ;Z now holds VAL16
but AVR has no such 16-bit loads, so I need to do the load as two 8-bit loads. I can do
lds ZL,var16 lds ZH,var16+1 ;Z now holds VAL16
but I'm just wondering if there's anything in the Atmel assembler that makes that a bit cleaner (like the low,high keywords).
but I'm just wondering if there's anything in the Atmel assembler that makes that a bit cleaner (like the low,high keywords).
So there are a series of helper macros, including one for what you are describing. You could easily create your own. The examples of definition and use below have an additional parameter as the offset...
R31:R30--
.MACRO __GETW1MN
LDS R30,@0+(@1)
LDS R31,@0+(@1)+1
.ENDM
32-bit --
.MACRO __GETD1MN
LDS R30,@0+(@1)
LDS R31,@0+(@1)+1
LDS R22,@0+(@1)+2
LDS R23,@0+(@1)+3
.ENDM
Arbitrary register pair --
.MACRO __GETWRMN
LDS R@0,@2+(@3)
LDS R@1,@2+(@3)+1
.ENDM
...
+
004854 91e0 1ca2+LDS R30 , _fmod_name + ( 32 )
004856 91f0 1ca3+LDS R31 , _fmod_name + ( 32 ) + 1
__GETW1MN _fmod_name,32
...
+
005ae0 9100 1d14+LDS R16 , 0 + ( _FatFs_G002 )
005ae2 9110 1d15+LDS R17 , 0 + ( _FatFs_G002 ) + 1
__GETWRMN 16,17,0,_FatFs_G002
...
+
005b51 9140 1d14+LDS R20 , 0 + ( _FatFs_G002 )
005b53 9150 1d15+LDS R21 , 0 + ( _FatFs_G002 ) + 1
__GETWRMN 20,21,0,_FatFs_G002
A few macros I use.
;Load immediate a register pair with a value. registers r16-r30 ; .MACRO LDIW ;Arguments: Register pair, Data (ie zl,zh,1234) ldi @0,low (@2) ldi @1,high (@2) .ENDMACRO ;Load immediate X with a value. ; .MACRO LDI_X ;Arguments: Data (ie 1234) ldi xl,low (@0) ldi xh,high (@0) .ENDMACRO ;Load immediate Z with a value. ; .MACRO LDI_Y ;Arguments: Data (ie 1234) ldi yl,low (@0) ldi yh,high (@0) .ENDMACRO ;Load immediate Z with a value. ; .MACRO LDI_Z ;Arguments: Data (ie 1234) ldi zl,low (@0) ldi zh,high (@0) .ENDMACRO
edit I think I got it wrong. :oops: If you want to get the value stored at the label then you neeed to write at least 2 different macros, 1 for EEPROM and 1 for FLASH as the 2 types of memories need to be accessed differently.
The 'low' and 'high' keywords work specifically on addresses usually for labels:
[code]
mystring: .db "Does this work?"
ldi zl, low (mystring)
ldi zh, high (mystring)
lpm r16,z ; r16 has 'D' after execution
Here the z register is acting like a pointer (a variable that holds an address) to get data from Flash program memory. I suspect, but I'm not sure that 'low' and 'high' will work on a 16-bit variable.
Using var and var+1 to access the 8-bit sections of a 16-bit variable is risky because you shouldn't have to remember whether the low or the high part of the variable is stored first in memory. Code might work well on one processor type and then fail on a different processor type. The shift-method of isolating the high and low sections of a variable does work.
Another thing to think about is avoiding the whole 8-bit mind-set totally. 32-bit ARM processors are beginning to approach high-end AVRs in price and some ARMs are selling for a few dollars each. With ARMs assembler code is irrelevant and register/memory locations fit nearly all data types. We are beginning to get away from making our programming style fit the processor and more towards selecting a processor to fit our programming style.
The reply that said use
The first question I would have is whether the value you want to load is in SRAM, EEPROM, or flash. As John said, different methods for each.
If it's in flash, then you must use the LPM instruction, and those will be word addresses, not byte addresses. You'll need to tweak them.
From SRAM it's all byte addresses and you have a choice of instructions.
The 'low' and 'high' keywords work specifically on addresses usually for labels:[code]
mystring: .db "Does this work?"ldi zl, low (mystring)
ldi zh, high (mystring)
lpm r16,z ; r16 has 'D' after execution
Using var and var+1 to access the 8-bit sections of a 16-bit variable is risky because you shouldn't have to remember whether the low or the high part of the variable is stored first in memory.
[code]
mystring: .db "Does this work?"ldi zl, low (mystring)
ldi zh, high (mystring)
lpm r16,z ; r16 has 'D' after execution
If it's in flash, then you must use the LPM instruction, and those will be word addresses, not byte addresses. You'll need to tweak them.
you must use the LPM instruction, and those will be word addresses, not byte addresses
