Eine Frage bzg. Macro in AVR-Assembler

[Maxim B. (max182)]

Guten Tag!
Ich habe eine Frage bzg. Macro in AVR-Assembler.

Um Macro unabhängig von Adresse zu machen, verwendet man Schreibweise:
[asm]
.macro outi    ; @0 Ziel, @1 Data, r24 wird benutzt
  ldi r24, @1
  .if @0 < 0x40
    out @0, r24
  .else
    sts @0, r24
  .endif
.endm
[/asm]

Leider arbeitet das mit Registernummer nicht. Solche Variante:
[asm]
.macro ldi8x  ; @0 Reg, @1 Data8
  .if @0 > 15
    ldi @0,@1
  .else
    ldi r24,@1
    mov @0,r24
  .endif
.endm
[/asm]
wird als error erkannt:
error: syntax error, unexpected REGISTER
Wenn statt .if @0 > 15 .if @0 > r15 zu schreiben, ändert sich nichts.

Die Frage: gibt es eine Möglichkeit, Macro für Arbeit mit Register
unabhängig von Registernummer zu schreiben?

Vielen Dank im voraus

P.S. bisher habe ich nur eine Möglichkeit gefunden, aber sie sieht nicht 
so schön aus. Vielleicht gibt es bessere Varianten?
Gefundene Möglichkeit:

[asm]
.equ REG0  = 0
.equ REG1  = 1
.equ REG2  = 2
.equ REG3  = 3
.equ REG4  = 4
.equ REG5  = 5
.equ REG6  = 6
.equ REG7  = 7
.equ REG8  = 8
.equ REG9  = 9
.equ REG10  = 10
.equ REG11  = 11
.equ REG12  = 12
.equ REG13  = 13
.equ REG14  = 14
.equ REG15  = 15
.equ REG16  = 16
.equ REG17  = 17
.equ REG18  = 18
.equ REG19  = 19
.equ REG20  = 20
.equ REG21  = 21
.equ REG22  = 22
.equ REG23  = 23
.equ REG24  = 24
.equ REG25  = 25
.equ REG26  = 26
.equ REG27  = 27
.equ REG28  = 28
.equ REG29  = 29
.equ REG30  = 30
.equ REG31  = 31

.macro ldi8x  ; @0 REG_Nr, @1 Data8
  .if  @0 == 0
    ldi r24,@1
    mov r0,r24
  .elif @0 == 1
    ldi r24,@1
    mov r1,r24
  .elif @0 == 2
    ldi r24,@1
    mov r2,r24
  .elif @0 == 3
    ldi r24,@1
    mov r3,r24
  .elif @0 == 4
    ldi r24,@1
    mov r4,r24
  .elif @0 == 5
    ldi r24,@1
    mov r5,r24
  .elif @0 == 6
    ldi r24,@1
    mov r6,r24
  .elif @0 == 7
    ldi r24,@1
    mov r7,r24
  .elif @0 == 8
    ldi r24,@1
    mov r8,r24
  .elif @0 == 9
    ldi r24,@1
    mov r9,r24
  .elif @0 == 10
    ldi r24,@1
    mov r10,r24
  .elif @0 == 11
    ldi r24,@1
    mov r11,r24
  .elif @0 == 12
    ldi r24,@1
    mov r12,r24
  .elif @0 == 13
    ldi r24,@1
    mov r13,r24
  .elif @0 == 14
    ldi r24,@1
    mov r14,r24
  .elif @0 == 15
    ldi r24,@1
    mov r15,r24
  .elif @0 == 16
    ldi r16,@1
  .elif @0 == 17
    ldi r17,@1
  .elif @0 == 18
    ldi r18,@1
  .elif @0 == 19
    ldi r19,@1
  .elif @0 == 20
    ldi r20,@1
  .elif @0 == 21
    ldi r21,@1
  .elif @0 == 22
    ldi r22,@1
  .elif @0 == 23
    ldi r23,@1
  .elif @0 == 24
    ldi r24,@1
  .elif @0 == 25
    ldi r25,@1
  .elif @0 == 26
    ldi r26,@1
  .elif @0 == 27
    ldi r27,@1
  .elif @0 == 28
    ldi r28,@1
  .elif @0 == 29
    ldi r29,@1
  .elif @0 == 30
    ldi r30,@1
  .elif @0 == 31
    ldi r31,@1
  .endif
.endm


ldi8x REG15,5
[/asm]

[Horst M. (horst)]

Schau mal hier: Beitrag "AVR Assembler, Macro, Conditional mit Register"

Vielleicht kannst Du was draus übernehmen.

[Maxim B. (max182)]

Danke.
Leider fand ich dort nichts Neues für mich. Auch keine Lösung, wie man 
Registernummer als .if-Parameter verwenden kann (nur etwa wie ich schon 
gemacht habe).

Na gut, vielleicht gibt es eine andere Lösung gar nicht.

Vielleicht darf ich noch eine Frage stellen:
Allgemein wird oft gesagt: man kann für ein Register mehrere .def 
machen. In Praxis kommt aber immer Warning. Wenn viele nicht sinnvollen 
Warnings kommen, kann man vielleicht was Wichtiges nicht merken. Da in 
Dateien von Mikrocontroller so wie m644PAdef.inc die Register r26-r31 
schon als XYZ definiert sind, kann man für diese Register keine defs 
mehr machen. Auch Beispiele von Atmel selbst (so wie APPLICATION NOTE 
AVR200 ) geben Warning.

Warscheinlich kann man Warnings bzg. mehrfachen .defs irgendwo 
abschalten. Aber wie genau macht man das?

[S. Landolt (Gast)]

Zur ursprünglichen Frage (avrasm2):

.macro ldi8x  ; @0 Reg, @1 Data8
.if  @0 > 15
    ldi r@0,@1
.else
    ldi r24,@1
    mov r@0,r24
.endif
.endm

 ldi8x 9,'S'
 ldi8x 21,'S'

Zur zweiten: eventuell #define verwenden.

[LostInMusic (Gast)]

>Allgemein wird oft gesagt: man kann für ein Register mehrere .def
>machen. In Praxis kommt aber immer Warning.

"undef" verwenden?

.def accu = r16
.undef accu
.def count = r16 
.undef count
.def sensor = r16

[Maxim B. (max182)]

Leider gibt Variante

.macro ldi8x  ; @0 reg, @1 Data8
  .if @0 > 15
    ldi r@0,@1
  .else
    ldi r24,@1
    mov r@0,r24
  .endif
.endm

ldi8x r15,5
ldi8x r16,9

auch error: syntax error, unexpected REGISTER

Kann ich mit #define bestimmte Warning ausschalten?

[Maxim B. (max182)]

LostInMusic schrieb:
> "undef" verwenden?

Das bringt nichts: so kann man entweder Eines oder Anderes verwenden.
In avr200.asm steht aber:

.def  mc8u  =r16    ;multiplicand
.def  mp8u  =r17    ;multiplier
.def  m8uL  =r17    ;result Low byte
.def  m8uH  =r18    ;result High byte
.def  mcnt8u  =r19    ;loop counter

Komisch, daß selbst der Entwickler von AVR Beispielcode gibt, der die 
Warnings auslöst.

warning: Register r17 already defined by the .DEF directive

[c-hater (Gast)]

Maxim B. schrieb:

> Leider fand ich dort nichts Neues für mich. Auch keine Lösung, wie man
> Registernummer als .if-Parameter verwenden kann (nur etwa wie ich schon
> gemacht habe).

Dann bist du blöd, denn genau so eine Lösung wurde im Thread gepostet, 
nämlich von mir.

[Maxim B. (max182)]

c-hater schrieb:
> Dann bist du blöd, denn genau so eine Lösung wurde im Thread gepostet,
> nämlich von mir.

Meinst du das?

.macro fetch_byte
  .set r16_macroprobe = 0
  .set @0_macroprobe = 1
  .if r16_macroprobe
    rcall read_byte
  .else
    push r16
    rcall read_byte
    mov @0,r16
    pop r16
  .endif
.endm

D.h. du stellst r16_macroprobe in Null und gleich danach prüfst mit .if, 
ob r16_macroprobe doch zufällig nicht Eins wird? Deinen Humor verstehe 
ich schlecht...

[S. Landolt (Gast)]

Also manchmal ... !-?

Maxim B. schrieb:
> Leider gibt Variante.macro ldi8x  ; @0 reg, @1 Data8
> ldi8x r15,5
> ldi8x r16,9
> auch error: syntax error, unexpected REGISTER

S. Landolt schrieb:
> ldi8x 9,'S'
> ldi8x 21,'S'

[c-hater (Gast)]

Maxim B. schrieb:

> D.h. du stellst r16_macroprobe in Null und gleich danach prüfst mit .if,
> ob r16_macroprobe doch zufällig nicht Eins wird?

Ganz genau. Das passiert nämlich nur genau dann, wenn tatsächlich r16 
als Parameter an das Makro übergeben wurde.

> Deinen Humor verstehe
> ich schlecht...

Das hat mit Humor nix zu schaffen. Es ist nur die einfachste 
Möglichkeit, diese Funktion mit dem AVR-Assembler zu realisieren.

[S. Landolt (Gast)]

> Kann ich mit #define bestimmte Warning ausschalten?
So ungefähr - es erlaubt zum Beispiel Folgendes ohne Warnung:

#define hinz  r30
#define kunz  ZL
 ldi ZL,45
 ldi hinz,67
 ldi kunz,89

Und haben Sie endlich Ihre überflüssigen 'r' im Macro-Aufruf entdeckt?

[Thomas R. (analogfreak)]

Zu "in/out unabhängig von Adresse" empfehle ich "application note AVR001 
- Conditional Assembly" (Include-Datei hängt an). Die 
Atmel-Originaldatei hieß "macros.inc". Ich habe gegenüber dem Original 
die übliche Prep-Pro.-Mimik hinzugefügt, damit mehrfaches Include geht.

AVRASM .if geht nur mit Zahlen. AVRASM hat keine Stringfunktionen außer 
"strlen". In Makros geht immerhin "zusammenkleben". r@0 wurde ja schon 
geschrieben.

"undef" wurde schon genannt. Wie geschrieben, werden xl, xh, ... in den 
Dateien wie m644PAdef.inc per .def definiert. Diese Definitionen kann 
man aber selbst gleich nach dem .include per .undef aufheben, wenn man 
den Registern selbst Namen gehen möchte und Warnungen vermeiden will.
x, y und z scheinen dagegen in AVRASM fest "verdrahtet" zu sein.

[S. Landolt (Gast)]

> x, y und z scheinen dagegen in AVRASM fest "verdrahtet" zu sein.
Auch daran lässt sich mit #define vorbeikommen:

#define  Zeiger  z
  ldd  r16,Zeiger+12

[c-hater (Gast)]

Thomas R. schrieb:

> AVRASM .if geht nur mit Zahlen.

Genau. Das .if zwingt den Assembler, die bis dahin reine Textersetzung 
zu evaluieren, d.h.: tatsächlich Werte auszurechnen.

> AVRASM hat keine Stringfunktionen außer
> "strlen". In Makros geht immerhin "zusammenkleben".

Also letztlich nicht viel anders als z.B. beim C-Präprozessor (der 
übrigens zusätzlich zum "nativen" ebenfalls im AVR-Assembler verfügbar 
ist). Das Einzige, was tatsächlich fehlt, ist die "stringification" von 
Zahlen, also so ziemlich das Umgekehrte von dem, was bei der Auswertung 
bei .if passiert.

> x, y und z scheinen dagegen in AVRASM fest "verdrahtet" zu sein.

Sind sie, wenn man sie als Adressierungsangabe für einen Opcode 
verwendet. Also kann man (mittels Präprozessor-Textersetzung) auch darum 
herumlavieren und z.B. so ein Codestück (assemblierbar und lauffähig) 
produzieren:

ldi DPTRL, Low(FlashAddr)
ldi DPTRH, High(FlashAddr
lpm r0, DPTR+

Der dafür nötige deklarativen Vorspann sieht so aus:

.UNDEF ZL                .UNDEF ZH
.DEF DPTRL = R30
.DEF DPTRH = R31
#define DPTR Z

Wahnsinn. Mit dieser Source-Warze könnte man auch gleich in C 
programieren. Das sieht zwar anders aus, besteht aber weit überwiegend 
aus genau solchen deklarativen Geschwüren ohne jeden sinnvollen Beitrag 
zum Code...

[Rainer V. (a_zip)]

Auch wenn ich mich jetzt als großer nerd outen sollte, stelle ich mal 
die Frage, warum ich ich das wollen sollte...

Maxim B. schrieb:
> Die Frage: gibt es eine Möglichkeit, Macro für Arbeit mit Register
> unabhängig von Registernummer zu schreiben?

Wie c-hater, für mich schon richtig, bemerkt hat, geht dieser Wunsch 
doch in eine Richtung, die man "mit assembler" überhaupt nicht haben 
will. Ich entscheide, was ich mit @0 meine und da brauche ich doch keine 
weitere "funktionale Zuordnung"! Aber wie gesagt, ich könnte das Problem 
auch einfach nicht verstanden haben.
Gruß Rainer

[c-hater (Gast)]

Rainer V. schrieb:

> Wie c-hater, für mich schon richtig, bemerkt hat, geht dieser Wunsch
> doch in eine Richtung, die man "mit assembler" überhaupt nicht haben
> will.

Das ist nicht ganz der Punkt. Der vergleichsweise Luxus von C wäre schon 
an vielen Stellen durchaus schick (unter Inkaufnahme der aufgeblähten 
Syntax, die aber letztlich erst den Luxus möglich macht).

Die Sache ist: wenn man sich bewußt (aus welchen Gründen auch immer) 
dafür entschieden hat, in Asm zu entwickeln, muss man sicher nicht seine 
Zeit damit vertrödeln, irgendwelche Macros zu bauen, deren Aufgabe 
einzig ist, dass es "fast" wie C benutzbar wird. Das ist absoluter 
Schwachsinn. Das kann C selber viel besser, indem man einfach wirklich 
gleich in C schreibt. C ist de facto schließlich der hochentwickeltste 
Macro-Assembler aller Zeiten. Jedenfalls für sehr viele Architekturen.

Nö, man übernimmt das C-Sprachkonzept nur soweit, wie sinnvoll (also 
insbesondere: noch nicht störend) ist und man ignoriert alle 
Konventionen der C-Runtime). Das zusammen macht den Trick. So kann man 
einerseits les- und wartbare Asm-Programme schreiben, andererseits aber 
enorme Performance-Vorteile erreichen.

[Rainer V. (a_zip)]

Ja, c-h, aber der Luxus ist letztlich doch auch mein Ding nicht. Ich 
will doch über Makros keine "Hochsprachen-Funktionen" in mein 
bescheidenes Programm holen. Mit Makros mache ich eine klitzekleine 
Vereinbarung, die fast nichts macht, aber vielleicht oft gebraucht wird, 
und deshalb einfach nicht 1000-mal getippt werden möcht...ok?
Gruß Rainer

[c-hater (Gast)]

Rainer V. schrieb:

> Ja, c-h, aber der Luxus ist letztlich doch auch mein Ding nicht. Ich
> will doch über Makros keine "Hochsprachen-Funktionen" in mein
> bescheidenes Programm holen. Mit Makros mache ich eine klitzekleine
> Vereinbarung, die fast nichts macht, aber vielleicht oft gebraucht wird,
> und deshalb einfach nicht 1000-mal getippt werden möcht...ok?

Was was genau ist daran deiner Meinung nach qualitativ anders als am 
Grundkonzept von C?

Nö, der Unterschied ist einfach nur quantitativ. Etwa: Was an 
Performance bin ich bereit zu opfern, um meine mühsam erstellten Macros 
benutzen zu können. Das fällt in Asm schlicht viel leichter, weil man 
typisch nicht so viele vorgefertigte Macros hat (oder sie zumindest 
leichter anpassen/erweitern kann, weil sie eigenes Werk und nicht tief 
und quasi unveränderlich im Compiler mit Abhängigkeit zur Runtime 
begraben sind)...

[Maxim B. (max182)]

S. Landolt schrieb:
> Und haben Sie endlich Ihre überflüssigen 'r' im Macro-Aufruf entdeckt?

Ich habe Sie falsch verstanden. Ich dachte, Sie sagten, ich muß r@0 
schreiben. Ich selber wollte statt r0-r31 @0 usw, somit wären Varianten 
wie @0+4 möglich. Z.B.:

.macro ldix8
.if @0>15
  ldi @0,@1
.else
  ldi r16,@1
  mov @0,r16
.endm

.macro ldix16
  ldix8 @0,low(@1)
  ldix8 @0+1,high(@1)
.endm

.macro ldix32
  ldix16 @0,(@1)&&0xffff
  ldix16 @0+2,((@1)>>16)&&0xffff
.endm

ldix32 r14,0xf1c2658a

Wenn ich aber absolute Adresse von Register schreiben muß, wo habe ich 
Gewinn?
Mein Wunsch wäre, daß in Macro Unterschied zwischen r0-r15 und r16-r31 
erkannt wird, so daß ich gewöhnliche Syntax mit Register verwenden 
könnte.

Meine Variante mit REG0-REG31 macht @+x möglich, Preis dafür ist aber, 
daß ich statt r0-r31 REG0-REG31 schreiben muß. Das gefällt mir nicht.

S. Landolt schrieb:
> So ungefähr - es erlaubt zum Beispiel Folgendes ohne Warnung:#define
> hinz  r30
> #define kunz  ZL
>  ldi ZL,45
>  ldi hinz,67
>  ldi kunz,89

Danke!
Ich werde das gleich ausprobieren.

Thomas R. schrieb:
> Zu "in/out unabhängig von Adresse" empfehle ich "application note AVR001
> - Conditional Assembly" (Include-Datei hängt an). Die
> Atmel-Originaldatei hieß "macros.inc". Ich habe gegenüber dem Original
> die übliche Prep-Pro.-Mimik hinzugefügt, damit mehrfaches Include geht.
>
> AVRASM .if geht nur mit Zahlen. AVRASM hat keine Stringfunktionen außer
> "strlen". In Makros geht immerhin "zusammenkleben". r@0 wurde ja schon
> geschrieben.

Danke für die Erklärung! Ich werde das alles versuchen.

Rainer V. schrieb:
> für mich schon richtig, bemerkt hat, geht dieser Wunsch
> doch in eine Richtung, die man "mit assembler" überhaupt nicht haben
> will. Ich entscheide, was ich mit @0 meine

Assembler hat auch Vorteile gegen C. In Assembler wird gemacht, wie ich 
will. In C wird alles vom Compiler entschieden. Manchmal kostet viel 
Zeil, zu erreichen, daß notwendige Sachen nicht wegoptimiert werden und 
trotzdem effiziente Code kommt. Manchmal nervt mich selbst Gedanke, daß 
eine Maschine mir Menschen etwas vorschreiben will.

[Maxim B. (max182)]

c-hater schrieb:
> Ganz genau. Das passiert nämlich nur genau dann, wenn tatsächlich r16
> als Parameter an das Makro übergeben wurde.

Danke!!! Das arbeitet! Ich verstehe zwar nicht, wie, aber das arbeitet 
:)

.macro ldix8
  .set r16_macroprobe = 0
  .set r17_macroprobe = 0
  .set r18_macroprobe = 0
  .set r19_macroprobe = 0
  .set r20_macroprobe = 0
  .set r21_macroprobe = 0
  .set r22_macroprobe = 0
  .set r23_macroprobe = 0
  .set r24_macroprobe = 0
  .set r25_macroprobe = 0
  .set r26_macroprobe = 0
  .set r27_macroprobe = 0
  .set r28_macroprobe = 0
  .set r29_macroprobe = 0
  .set r30_macroprobe = 0
  .set r31_macroprobe = 0
  .set @0_macroprobe = 1
  .if r16_macroprobe
    ldi @0,@1
  .elif r17_macroprobe
    ldi @0,@1
  .elif r18_macroprobe
    ldi @0,@1
  .elif r19_macroprobe
    ldi @0,@1
  .elif r20_macroprobe
    ldi @0,@1
  .elif r21_macroprobe
    ldi @0,@1
  .elif r22_macroprobe
    ldi @0,@1
  .elif r23_macroprobe
    ldi @0,@1
  .elif r24_macroprobe
    ldi @0,@1
  .elif r25_macroprobe
    ldi @0,@1
  .elif r26_macroprobe
    ldi @0,@1
  .elif r27_macroprobe
    ldi @0,@1
  .elif r28_macroprobe
    ldi @0,@1
  .elif r29_macroprobe
    ldi @0,@1
  .elif r30_macroprobe
    ldi @0,@1
  .elif r31_macroprobe
    ldi @0,@1
  .else
    ldi r16,@1
    mov @0,r16
  .endif
.endm


start:
nop
ldix8 r15,5
ldix8 r16,6
ldix8 r17,7
ldix8 r2,0x23
ldix8 r5,0xfd
ldix8 r24,0xaa
ldix8 r16,0x11
ldix8 r22,0x88
rjmp start

[S. Landolt (Gast)]

> Danke!!! Das arbeitet!

Aha, interessant - und wie funktioniert nun das von Ihnen verlangte
> ldix32 r14,0xf1c2658a
d.h. das automatische Hochzählen von Registernummern?

[S. Landolt (Gast)]

PS:
Denn ldix8 alleine hat schließlich auch in der von mir vorgeschlagenen 
Macro-Version funktioniert.

[Maxim B. (max182)]

Ich mache jetzt verschiedene Proben. Eine Variante ermöglich indirekte 
Register nicht, dafür aber "natürliche" Syntax. Andere Variante 
umgekehrt, unnatürlichen Syntax, aber indirekte Register :)

.macro setr16
  .set r16_macroprobe = 0
  .set r17_macroprobe = 0
  .set r18_macroprobe = 0
  .set r19_macroprobe = 0
  .set r20_macroprobe = 0
  .set r21_macroprobe = 0
  .set r22_macroprobe = 0
  .set r23_macroprobe = 0
  .set r24_macroprobe = 0
  .set r25_macroprobe = 0
  .set r26_macroprobe = 0
  .set r27_macroprobe = 0
  .set r28_macroprobe = 0
  .set r29_macroprobe = 0
  .set r30_macroprobe = 0
  .set r31_macroprobe = 0
.endm

.macro ldireg  ; @0 r0-r31, @1 Data8, 1-2c
        ; Beispiel: ldireg r15,25
        ; wenn r0-r15, r16 benutzt
  setr16
  .set @0_macroprobe = 1
  
  .if r16_macroprobe
    ldi @0,@1
  .elif r17_macroprobe
    ldi @0,@1
  .elif r18_macroprobe
    ldi @0,@1
  .elif r19_macroprobe
    ldi @0,@1
  .elif r20_macroprobe
    ldi @0,@1
  .elif r21_macroprobe
    ldi @0,@1
  .elif r22_macroprobe
    ldi @0,@1
  .elif r23_macroprobe
    ldi @0,@1
  .elif r24_macroprobe
    ldi @0,@1
  .elif r25_macroprobe
    ldi @0,@1
  .elif r26_macroprobe
    ldi @0,@1
  .elif r27_macroprobe
    ldi @0,@1
  .elif r28_macroprobe
    ldi @0,@1
  .elif r29_macroprobe
    ldi @0,@1
  .elif r30_macroprobe
    ldi @0,@1
  .elif r31_macroprobe
    ldi @0,@1
  .else
    ldi r16,@1
    mov @0,r16
  .endif
.endm

.macro exorireg    ; @0 r0-r31, @1 Data8, 2c, wenn r16, 6c
          ; Beispiel: exorireg r15,25
          ; r16 benutzt
  .set r16_macroprobe = 0
  .set @0_macroprobe = 1
  .if r16_macroprobe
    push r17
    ldi r17,@1
    eor r16,r17
    pop r17
  .else
    ldi r16,@1
    eor @0,r16
  .endif
.endm

ldireg r5,18
ldireg r18,6
exorireg r18,2

.equ REG0  = 0
.equ REG1  = 1
.equ REG2  = 2
.equ REG3  = 3
.equ REG4  = 4
.equ REG5  = 5
.equ REG6  = 6
.equ REG7  = 7
.equ REG8  = 8
.equ REG9  = 9
.equ REG10  = 10
.equ REG11  = 11
.equ REG12  = 12
.equ REG13  = 13
.equ REG14  = 14
.equ REG15  = 15
.equ REG16  = 16
.equ REG17  = 17
.equ REG18  = 18
.equ REG19  = 19
.equ REG20  = 20
.equ REG21  = 21
.equ REG22  = 22
.equ REG23  = 23
.equ REG24  = 24
.equ REG25  = 25
.equ REG26  = 26
.equ REG27  = 27
.equ REG28  = 28
.equ REG29  = 29
.equ REG30  = 30
.equ REG31  = 31

.macro ldi8_x  ; @0 REG_Nr, @1 Data8, r16 benutzt
  .if  @0 == 0
    ldi r16,@1
    mov r0,r16
  .elif @0 == 1
    ldi r16,@1
    mov r1,r16
  .elif @0 == 2
    ldi r16,@1
    mov r2,r16
  .elif @0 == 3
    ldi r16,@1
    mov r3,r16
  .elif @0 == 4
    ldi r16,@1
    mov r4,r16
  .elif @0 == 5
    ldi r16,@1
    mov r5,r16
  .elif @0 == 6
    ldi r16,@1
    mov r6,r16
  .elif @0 == 7
    ldi r16,@1
    mov r7,r16
  .elif @0 == 8
    ldi r16,@1
    mov r8,r16
  .elif @0 == 9
    ldi r16,@1
    mov r9,r16
  .elif @0 == 10
    ldi r16,@1
    mov r10,r16
  .elif @0 == 11
    ldi r16,@1
    mov r11,r16
  .elif @0 == 12
    ldi r16,@1
    mov r12,r16
  .elif @0 == 13
    ldi r16,@1
    mov r13,r16
  .elif @0 == 14
    ldi r16,@1
    mov r14,r16
  .elif @0 == 15
    ldi r16,@1
    mov r15,r16
  .elif @0 == 16
    ldi r16,@1
  .elif @0 == 17
    ldi r17,@1
  .elif @0 == 18
    ldi r18,@1
  .elif @0 == 19
    ldi r19,@1
  .elif @0 == 20
    ldi r20,@1
  .elif @0 == 21
    ldi r21,@1
  .elif @0 == 22
    ldi r22,@1
  .elif @0 == 23
    ldi r23,@1
  .elif @0 == 24
    ldi r24,@1
  .elif @0 == 25
    ldi r25,@1
  .elif @0 == 26
    ldi r26,@1
  .elif @0 == 27
    ldi r27,@1
  .elif @0 == 28
    ldi r28,@1
  .elif @0 == 29
    ldi r29,@1
  .elif @0 == 30
    ldi r30,@1
  .elif @0 == 31
    ldi r31,@1
  .endif
.endm

.macro ldi8x  ; @0 REG, @1 Data8  1 oder 2 c
        ; wenn REG 0...15, r16 benutzt
    ldi8_x @0,@1
.endm

.macro ldi16x  ; @0 untere REG_Nr, @1 Data16 2-4 c
        ; wenn REG 0...14, r16 benutzt
    ldi8_x @0,low(@1)
    ldi8_x @0+1,high(@1)
.endm

.macro ldi24x  ; @0 untere REG_Nr, @1 Data24  3-6 c
        ; wenn REG 0...13, r16 benutzt
    ldi8_x @0,low(@1)
    ldi8_x @0+1,high(@1)
    ldi8_x @0+2,byte3(@1)
.endm

.macro ldi32x  ; @0 untere REG_Nr, @1 Data32  4-8c
        ; wenn REG 0...12, r16 benutzt
    ldi8_x @0,low(@1)
    ldi8_x @0+1,high(@1)
    ldi8_x @0+2,byte3(@1)
    ldi8_x @0+3,byte4(@1)
.endm

.macro ldi40x  ; @0 untere REG_Nr, @1 Data40  5-10c
        ; wenn REG 0...11, r16 benutzt
    ldi32x @0,@1
    ldi8_x @0+4,(@1>>32)&0xff
.endm

ldi32x REG5,0x01020304

[Maxim B. (max182)]

Ich habe Gefühl, man kann besser machen. Aber wie?

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Ich habe Gefühl, man kann besser machen. Aber wie?

Fachbücher lesen? Einen guten Kurs besuchen? Grundlagen erlernen (im 
Selbststudium) - so etwas ähnliches mit "Schwarmintelligenz" machst Du 
ja, aber ob Dir das wirklich etwas bringt?

Google scheint nicht unbedingt Dein Freund zu sein, scheint mir. Schau 
doch mal ein wenig rum - z. B.:

https://www.schramm-software.de/tipps/makros.htm

Einfach mal "avr assembler makro" bei Google eingeben und rumstöbern 
kannst Du nicht?

[Marc V. (Firma: Vescomp) (logarithmus)]

Maxim B. schrieb:
> Ich habe Gefühl, man kann besser machen. Aber wie?

 Versuch es mit C, BASIC, irgendwas - alles ist besser als das, was du
als macro gepostet hast...

[Maxim B. (max182)]

Marc V. schrieb:
> Versuch es mit C, BASIC, irgendwas - alles ist besser als das, was du
> als macro gepostet hast...

Na, Assembler-Polizei gibt es in Deutschland noch nicht. Man darf alles 
:)

Hugo H. schrieb:
> Google scheint nicht unbedingt Dein Freund zu sein

Das stimmt. Wenn ich Google etwas frage, dann bekomme ich ausschließlich 
Angebote etwas zu kaufen. Mehr kann Google leider nicht.

Alles, was ich in Internet bisher fand, beschreibt Anfang. Bis 
Macro-Syntax kommt kaum ein Buch, leider.
Wäre mein Lebenstraum mit LED zu blinken, dann wäre Google richtige 
Adresse für mich.

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Das stimmt. Wenn ich Google etwas frage, dann bekomme ich ausschließlich
> Angebote etwas zu kaufen.

Dann stellst Du die falschen Fragen. Hast Du mal meinen "Vorschlag" 
ausprobiert?

[Maxim B. (max182)]

Marc V. schrieb:
> Versuch es mit C

Meinst du das? Ja, ich habe das ausprobiert.
C bleibt sowieso. Aber ich möchte gerne auch etwas mit Assembler machen.

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Meinst du das?

Lesen kannst Du aber schon - oder?

[Maxim B. (max182)]

Hugo H. schrieb:
> https://www.schramm-software.de/tipps/makros.htm

Danke für Link. Ich lese gerade.

Hugo H. schrieb:
> Dann stellst Du die falschen Fragen.

Aus Pädagogik ist bekannt: falsche Fragen gibt es nicht. Es gibt nur 
falsche Lehrer.

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Aus Pädagogik ist bekannt: falsche Fragen gibt es nicht. Es gibt nur
> falsche Lehrer.

Was hat die Pädagogik mit Google gemeinsam? Natürlich gibt es falsche 
Fragen. Wenn Du die Uhrzeit wissen willst und fragst "Wo ist nächste 
Tankstelle" ist das nicht gerade die richtige Frage, um Deine 
Wissenslücke zu schließen - oder?

[Maxim B. (max182)]

Dein Link ist interessant. Leider wird nur Anfang beschrieben. Besonders 
weit mit Macros kommt Autor nicht, wie auch von ihm empfohlene Seite. 
Meine Frage wird dort leider nicht beantwortet (automatische Unterschied 
zwischen oberen und unteren Register und auch indirekte 
Registerzugriff).
 c-hater konnte mir hier mehr helfen.

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> c-hater konnte mir hier mehr helfen.

Das freut mich - viel Spaß noch :-)

[Maxim B. (max182)]

Natürlich hat Google mit Pädagogik wenig zu tun. Google will nur alles 
verkaufen und mit Werbung verdienen. Nur durch Zufall kann von Google 
etwas Nützliche kommen.

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Nur durch Zufall kann von Google
> etwas Nützliche kommen.

Im Falle dessen, der es nicht bedienen kann, stimme ich Dir voll
 und ganz zu.

[Marc V. (Firma: Vescomp) (logarithmus)]

Maxim B. schrieb:
> C bleibt sowieso. Aber ich möchte gerne auch etwas mit Assembler machen.

Kannst du auch in C ohne Probleme.
Ein Macro wird in Assembler immer in voller Länge eingefügt, eine
function mit entsprechenden Parametern in C aber nur einmal.

[Maxim B. (max182)]

Marc V. schrieb:
> Ein Macro wird in Assembler immer in voller Länge eingefügt

Das finde ich schön. Auch in C mag ich Macro und inline-Funktionen als 
volatile. Wenn ich Programmspeicher nicht vollständig benutze, bekomme 
ich kein Geld zurück. :)

Jetzt habe ich noch etwas bemerkt:
wenn ich so schreibe:

.if (var > Konst)
***
.endif

, arbeitet das nicht mit 2147483647. D.h. int32_t, 0x7FFFFFFF.
.if (var > 2147483647) wird immer war. Das liegt wohl in 
Assemblerprogramm.
Kann man das nicht umgehen?

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> int32_t

https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Ganzzahlige_Datentypen_.28Integer.29

[Maxim B. (max182)]

Was wolltest du damit sagen?

[Hugo H. (hugohurtig1)]

Maxim B. schrieb:
> Was wolltest du damit sagen?

Ich dachte, Du kannst Lesen? Was sagt Dir der Datentyp int32_t?

Das ist übrigens ein gutes Beispiel (aus meiner Sicht) für den 
Unterschied zwischen Assembler und Compiler (bzw. Interpreter).

Der Assembler setzt das, was Du vorgegeben hast, 1:1 in Maschinencode 
um. Du hast (fast) immer Recht.

Der Compiler versucht "zu ergründen" was Du willst und warnt Dich vor 
"unsinnigen" Befehlen.

Ein Interpreter (wie Basic) macht das gleiche - nur immer wieder zum 
Laufzeitpunkt - mit entsprechender Performance-Einbuße.

[c-hater (Gast)]

Marc V. schrieb:

> Ein Macro wird in Assembler immer in voller Länge eingefügt, eine
> function mit entsprechenden Parametern in C aber nur einmal.

Nein. Du lügst. C macht natürlich inlining.

Der Unterschied zu Asm ist: hier habe ich die volle Kontrolle, wofür 
genau. In C entscheidet das letztlich der Compiler. Und eben längst 
nicht immer richtig...

Man kann ein wenig frickeln, um ihn in die richtige Richtung zu lenken, 
aber die volle Kontrolle erlangt man nicht.

[c-hater (Gast)]

Maxim B. schrieb:

> Mein Wunsch wäre, daß in Macro Unterschied zwischen r0-r15 und r16-r31
> erkannt wird, so daß ich gewöhnliche Syntax mit Register verwenden
> könnte.

Wäre auch möglich, geht aber weiterhin in die falsche Richtung. Deswegen 
werde ich deine Bemühungen auch nicht weiter unterstützen, sondern 
empfehlen: nimm C.

Du bist wohl nicht für Asm geboren, du bist schließlich offensichtlich 
nicht einmal in der Lage, die Möglichkeiten des (eines!) Assemblers beim 
Präprozessing zu erkennen und zu benutzen. Es ist also kaum anzunehmen, 
dass du dann zur Laufzeit Bäume in Asm ausreissen wirst. Denn dazu ist 
es nötig (für jede Zielarchitektur auf's Neue) zu erkennen, was man 
damit tuen kann und wie man das am effizientesten tut, also dieselbe 
Challenge wie beim Präprozessor für die Assemblierzeit.
Es ist also mit extrem hoher Wahrscheinlichkeit davon auszugehen, dass 
dein Code deutlich schlechter werden wird, als hätte man ihn gleich in 
Schulbuch-C hingeschrieben und (mit Optimierung) kompiliert.

Unter solchen Voraussetzungen ergibt der Einsatz von Asm eher keinen 
Sinn. Die Sache ist: ein Assembler produziert exakt den Code, den die 
Fähigkeiten seines Programmierers erlauben. Ein C-Compiler kann hingegen 
besseren Code liefern, als es die Programmiererfähigkeiten eigentlich 
erlauben würden...

Deswegen wohl der verbreitete Eindruck, dass C schon alles richtet. Den 
haben vor allem diese Unmassen krass unfähiger C-only Programmierer...

[Maxim B. (max182)]

Hugo H. schrieb:
> Der Assembler setzt das, was Du vorgegeben hast, 1:1 in Maschinencode
> um. Du hast (fast) immer Recht.

Diese Frage betrifft aber Assembler nicht, nur Präprozessor.
Hast du gelesen, was ich zuletz gefragt habe? Oder kannst du nur 
schreiben?

c-hater schrieb:
> sondern
> empfehlen: nimm C.

Ich werde beides verwenden.

[Maxim B. (max182)]

c-hater schrieb:
> Du bist wohl nicht für Asm geboren

Ja, ich weiß. Ich bin für Bachsche Orgelmusik geboren. Und auch für 
Orgelmusik von Buxtehude. Elektronik ist nur Hobby für mich.
Ist das schlecht?

c-hater schrieb:
> Es ist also mit extrem hoher Wahrscheinlichkeit davon auszugehen, dass
> dein Code deutlich schlechter werden wird, als hätte man ihn gleich in
> Schulbuch-C hingeschrieben und (mit Optimierung) kompiliert.

Mag sein. Aber diese Spielerei mit Macro kann behilflich werden, wenn 
ich einen Algorithmus aus C auf Assembler verwenden möchte, ohne zu viel 
darüber zu denken (als Beispiel: Universelle Tastenabfrage, was ich 
gerne mehrmals in meine C-Proekte übernommen habe:
Beitrag "Universelle Tastenabfrage mit 2 Tastenerkennung"
Eine Erweiterung auf 16 oder auf 24 Tasten wird in C natürlich viel 
einfacher. Aber wenn alles Andere mit Assembler gemacht wird? ).

Wozu kann das behilflich sein? Ganz einfach: wenn das Programm auf 
Assembler geschrieben wird, aber eine oder zwei Funktionen relativ 
kompliziert sind und ich habe kein Vorbild auf Assembler gefunden.
Mit Assembler gehen die Sachen besser, die viel mit Peripherie zu tun 
haben und wo wenig von den Sachen ist, wofür C konzipiert ist 
(Peripherie macht sowieso Quelltext-Übertragen auf andere Systeme 
fragwürdig).
Z.B. wenn man, wie hier auf dem Forum irgendwo gepostet wurde, einen 
Ersatz für LM3914 machen will, paßt Assembler besser als C: ADC auslesen 
und entsprechend bestimmte Ausgänge umschalten. Vergleich mit Konstante 
und bedingte cbi und sbi.

c-hater schrieb:
> Ein C-Compiler kann hingegen
> besseren Code liefern, als es die Programmiererfähigkeiten eigentlich
> erlauben würden...

Gerade für Anfänger bedeutet C viel Kampf mit "Wegoptimieren" :)
Assembler macht genau was geschrieben. Um zu verstehen, welche Vorteil 
das bringt, lohnte es sich, C kennenzulernen...