AVR: unsigned 24 bit auf 3 Ports verteilen

[Michael A. (micha54)]

Hallo,

ich stolpere über ein Laufzeitproblem bei der Verteilung der 3 unteren 
Bytes eines 24-bit Wertes auf 3 Ports.

inline void machmal(uint32_t wert)
{
PORTA = (wert & 0xff);          // ok, OUT PORTA,Rn
PORTB = ((wert >> 8) & 0xff);   // 4 Register werden sinnlos umkopiert
PORTC = ((wert >> 16) & 0xff);  // ok, OUT PORTC, Rn+2
}

machmal(0x00112233UL);

Der gcc läuft mit -o3

Wie gehts besser ?
Union etc. geht nicht, weil ich alles in Registern behalten will.

Gruß,
Michael

[Jonas B. (jibi)]

Da fehlen die casts...

gruß Jonas

[Oliver S. (oliverso)]

Michael Appelt schrieb:
> Union etc. geht nicht, weil ich alles in Registern behalten will.

???

Solange du in C programmierst, hast du eh keinen Einfluß darauf.

Aber:

Schau dir das ABI an. Dein uint32-Wert steht ja beim Funktionsaufruf in 
4 Registern. Mit ein paar Zeilen inline-Assembler oder einer eigenen 
Assembler-Routine kannst du die Werte direkt aus den Registern in die 
Ports schreiben. Schneller gehst es nicht.

Oliver

[Jonas B. (jibi)]

>Solange du in C programmierst, hast du eh keinen Einfluß darauf.

Nicht komplett aber man kann mit dem Schlüsselwort register eine 
variable in den Registern halten.

Gruß Jonas

[Michael A. (micha54)]

Hallo,

@Oliver S:

Union geht über den Spicher und die genannte Sequenz und ein wenig mehr 
sollen unter 1us laufen.

Das ganze muss 6mal aufgerufen werden, und mir gefallen die hart 
kodierten Register nicht. Muss vermutlich tiefer in den inline-Assembler 
reinschauen.

@Jonas:

welche Casts ?

PORTB = (uint8_t) ((uint16_t) wert) >> 8);

Wäre das optimal ? Stimmt, hab ich noch nicht probiert.

Gruß,
Michael

[Peter D. (peda)]

Michael Appelt schrieb:
> Der gcc läuft mit -o3

Default sollte man -Os nehmen.
Besser gehts nicht:

inline void machmal(uint32_t wert)
{
PORTA = (wert & 0xff);          // ok, OUT PORTA,Rn
  d0:  83 e3         ldi  r24, 0x33  ; 51
  d2:  82 b9         out  0x02, r24  ; 2
PORTB = ((wert >> 8) & 0xff);   // 4 Register werden sinnlos umkopiert
  d4:  82 e2         ldi  r24, 0x22  ; 34
  d6:  85 b9         out  0x05, r24  ; 5
PORTC = ((wert >> 16) & 0xff);  // ok, OUT PORTC, Rn+2
  d8:  81 e1         ldi  r24, 0x11  ; 17
  da:  88 b9         out  0x08, r24  ; 8
}

[Oliver S. (oliverso)]

Jonas Biensack schrieb:
> Nicht komplett aber man kann mit dem Schlüsselwort register eine
> variable in den Registern halten.

Register allocation ist Sache des Compilers. Daher wird das 
Schlüsselwort register seit vielen Compiler-Generationen vom gcc 
schlicht ignoriert.

Peter Dannegger schrieb:
> Besser gehts nicht:

In reinem Assembler wären es nur die 3 out-Befehle und return.

Oliver

[Peter II (Gast)]

Oliver S. schrieb:
> In reinem Assembler wären es nur die 3 out-Befehle und return.

aber nur wenn die werte schon in einem Register stehen.

[Michael A. (micha54)]

Hallo,

naja, bei einem Call stehen diese Parameter bei meinem Programm immer in 
Registern. Am Anfang steht allerdings eine Variable.

Der Code von Peter ist da ein wenig zu optimistisch, aber ich probiers 
heute abend mit -Os

Gruß,
Michael

[Peter II (Gast)]

Michael Appelt schrieb:
> naja, bei einem Call stehen diese Parameter bei meinem Programm immer in
> Registern.

es gibt aber bei inline keinen call mehr.

[Peter D. (peda)]

Michael Appelt schrieb:
> Der Code von Peter ist da ein wenig zu optimistisch

Ja, durch das "inline" hat er zu gut optimiert.
Versuch mal erst zu maskieren und dann schieben.

[Oliver S. (oliverso)]

Peter II schrieb:
> aber nur wenn die werte schon in einem Register stehen.

Die Werte stehen in Registern, weil der gcc sie darin in die Funktion 
übergibt.

Oliver

[Peter II (Gast)]

Oliver S. schrieb:
> Die Werte stehen in Registern, weil der gcc sie darin in die Funktion
> übergibt.

aber nur wenn eine eine Funktion gibt, und bei inline gibt es keine 
Funktion mehr.

[Jonas B. (jibi)]

>naja, bei einem Call stehen diese Parameter bei meinem Programm immer in
>Registern.

nö, die können auch auf dem stack liegen.
Schon mal dran gedacht das es funktionensaufrufe mit mehr parametern als 
verfügbaren registern gibt?

Gruß Jonas

[Michael A. (micha54)]

Peter II schrieb:
> Michael Appelt schrieb:
>> naja, bei einem Call stehen diese Parameter bei meinem Programm immer in
>> Registern.
>
> es gibt aber bei inline keinen call mehr.

Aber auf die drüberliegenden Functions, die sind nicht inline.

Es sind 6 Functions f1....f6. Jede hat leicht unterschiedliche 
Parameter, d.h. es werden möglicherweise unterschiedliche Register 
benutzt. Jede ruft am Anfang die genannte inline function auf.

Wegen der Registerzuweisung bin ich mit inline asm nicht glücklich.
Wenn es so jetzt funktioniert, dann löst das mein Problem.

Gruß,
Michael

[Peter II (Gast)]

Michael Appelt schrieb:
> Aber auf die drüberliegenden Functions, die sind nicht inline.

die hast du uns aber nicht gezeigt, damit können wir das ja schlecht 
wissen.

[Michael A. (micha54)]

Hallo,

also man sollte schon in der Lage sein, abstrakt über ein Problem zu 
reden ohne immer gleich ein 8k-Programm im Source anzuhängen.

Ich habe ja nicht gesagt, daß der gcc was falsch macht und die Hinweise 
waren durchaus zutreffend genug, um damit mein Brett vorm Kopp zu 
entfernen.

Gruß,
Michael

[Yalu X. (yalu) (Moderator)]

Michael Appelt schrieb:
> Union etc. geht nicht, weil ich alles in Registern behalten will.

Michael Appelt schrieb:
> Union geht über den Spicher und die genannte Sequenz und ein wenig mehr
> sollen unter 1us laufen.

Wie kommst du darauf? Hast du's ausprobiert?

Wenn nicht, dann wage einen Versuch und sei überrascht ;-)

[Michael A. (micha54)]

Hallo,

nein, habe ich nicht probiert. Es würde auf Union als Parametertyp 
hinauslaufen, und da müsste ich mich ebenfalls erstmal einlesen.

Ich weiß garnicht:

Wo steht, dass man hier nur Fragen stellen darf, wenn man vorher bereits 
alles ausprobiert hat ?

Wo steht, dass man alles ausprobieren muss ?

Gruß,
Michael

[Peter D. (peda)]

Mit union:

void out24(uint32_t val)
{
  union{
    uint32_t u32;
    uint8_t u8[4];
  } in;
  in.u32 = val;
  PORTA = in.u8[0]; 
  PORTB = in.u8[1]; 
  PORTC = in.u8[2]; 
}

Das Listing:

000000c0 <out24>:
  union{
    uint32_t u32;
    uint8_t u8[4];
  } in;
  in.u32 = val;
  PORTA = in.u8[0]; 
  c0:  62 b9         out  0x02, r22  ; 2
  PORTB = in.u8[1]; 
  c2:  75 b9         out  0x05, r23  ; 5
  PORTC = in.u8[2]; 
  c4:  88 b9         out  0x08, r24  ; 8
}
  c6:  08 95         ret

[(prx) A. K. (prx)]

Wenn der Abstand zwischen den OUT Befehlen zwingend minimiert sein muss:

void __attribute__ ((noinline))
out24(uint8_t h, uint8_t m, uint8_t l)
{
        cli();
        PORTA = l;
        PORTB = m;
        PORTC = h;
        sei();
}

void f(uint32_t x)
{
        out24(x >> 16, x >> 8, x);
}

So spart man ein wenig an unkritischer Stelle, hat aber mehr Arbeit:

        out24(x >> 16, (uint16_t)x >> 8, x);

[Oliver S. (oliverso)]

Jonas Biensack schrieb:
> nö, die können auch auf dem stack liegen.

Bei irgendwelchen Compilern für irgendwelche Zielplattformen ja.

Beim avr-gcc mit einem uint32-Funktionsparameter wie im oben gezeigten 
Code liegt der immer in den Registern.

Oliver

[Michael A. (micha54)]

Hallo,

ok, ich muss zugeben, dass hat was :-))
Die Details des Union bleiben in der function verborgen.

Danke für die Mühe, die Ihr Euch gemacht habt.
Vermutlich bleibt es aber dabei: ohne -Os klappt es auch mit union 
nicht.

BTW die genaue Zeit der out-Befehle ist mir relativ egal, aber mal eben 
zusätzlich 4 register kopieren ging mir irgendwie quer - technisch wäre 
es aber relativ egal.

Gruß,
Michael

[Yalu X. (yalu) (Moderator)]

Michael Appelt schrieb:
> nein, habe ich nicht probiert. Es würde auf Union als Parametertyp
> hinauslaufen, und da müsste ich mich ebenfalls erstmal einlesen.
>
> Ich weiß garnicht:
>
> Wo steht, dass man hier nur Fragen stellen darf, wenn man vorher bereits
> alles ausprobiert hat ?

Nirgends, das ist ganz dir überlassen.

> Wo steht, dass man alles ausprobieren muss ?

Ebenfalls nirgends.

Nur tust du dir dann mit Aussagen wie der folgenden selber keinen
Gefallen:

Michael Appelt schrieb:
> Union geht über den Spicher

Denn das erweckt den Eindruck, dass du dir diesbezüglich sicher bist und
deswegen auch für die Helfenden keinerlei Bedarf siehst, die Unions doch
einmal auszuprobieren.

Ohne die obige Aussage wäre der Vorschlag mit der Union sicher schon in
der ersten oder zweiten Antwort gekommen, so waren aber alle Hirne erst
einmal blockiert.

Ich selber war mir erst auch nicht sicher, ob hier eine Union etwas
bringen würde. Nach einer kurzen Goole-Suche nach

  gcc struct argument register

kam ich zum aber Schluss, dass das zumindest einen Versuch wert ist. Und
siehe da ...

[Michael A. (micha54)]

Hallo,

jawoll, Du bist ein ganz schlauer, deshalb darfst Du ja auch Moderator 
sein.

Also ich habe ein Berufsleben, und privat geht mein Ehrgeiz zu einer 
angemessene Lösung in angemessener Zeit.

Aktuell erhalte ich bei -Os

  DATA_OUT = (uint8_t) ((uint16_t) adr >> 8);
 250:  27 2f         mov  r18, r23
 252:  33 27         eor  r19, r19
 254:  28 b9         out  0x08, r18  ; 8

Gruß,
Michael

[Peter II (Gast)]

Michael Appelt schrieb:
> Aktuell erhalte ich bei -Os
>
>   DATA_OUT = (uint8_t) ((uint16_t) adr >> 8);
>  250:  27 2f         mov  r18, r23
>  252:  33 27         eor  r19, r19
>  254:  28 b9         out  0x08, r18  ; 8

was macht das

eor  r19, r19

für einen sinn?

[(prx) A. K. (prx)]

Peter II schrieb:
> was macht das für einen sinn?
>>  250:  27 2f         mov  r18, r23
>>  252:  33 27         eor  r19, r19

Das ist die optimale Sequenz für einen 16-Bit Shift um 8 mit src=r22/23, 
dst=r18/19. Danach kommt die Zuweisung, die nur die untere Hälfte 
verwendet.

[Michael A. (micha54)]

Sorry, meine Frage war rein rhetorisch.

Ich wunder mich nur, was vom gcc alles optimiert wird und was 
andererseits manchmal auch nicht. Aber die Bewunderung der Entwickler 
überwiegt.

Nachtrag:

  DATA_OUT = (uint8_t) (adr >> 16);
 25a:  aa 27         eor  r26, r26
 25c:  bb 27         eor  r27, r27
 25e:  88 b9         out  0x08, r24  ; 8

Auch nicht schlecht....ich probiers wohl besser mit union.

Gruß,
Michael

[(prx) A. K. (prx)]

Peter II schrieb:
> was macht das
> eor  r19, r19
> für einen sinn?

Bei non-volatile lhs entfallen mov und eor.

[Falk B. (falk)]

Aus der Praxis.


.h

// little trick, to speed up data access

typedef union {          
    uint32_t d32;
    uint8_t ary[4];
    } ut_t;

.c

ISR(TIMER1_COMPA_vect) {

    static uint8_t pwm_cnt, slow_cnt;
    ut_t tmp;
    int8_t enc_new, enc_diff;           // encoder stuff

    OCR1A   += isr_ptr->time[pwm_cnt];
    tmp.d32  = isr_ptr->mask[pwm_cnt];

    if (pwm_cnt == 0) {                 // set ports at begin of PWM
        PORTD = tmp.ary[0] | 0x0F;      // PD0-3 no change
        PORTC = tmp.ary[1];
        PORTB = tmp.ary[2] | 0xF0;      // PB4-7 no change
        PORTA = tmp.ary[3];
        pwm_cnt++;
        slow_cnt++;
        if (slow_cnt == 10) {           // 100ms timer
            slow_cnt=0;
            flag_100ms=1;               // trigger lcd refresh
        }
    }
    else {                              // clear ports
        PORTD &= (tmp.ary[0] | 0x0F);       
        PORTC &= tmp.ary[1];
        PORTB &= tmp.ary[2] | 0xF0;
        PORTA &= tmp.ary[3];
                                
        if (pwm_cnt == pwm_cnt_max) {
            pwm_sync = 1;               // update now possible
            pwm_cnt=0;
        }
        else pwm_cnt++;
    }
    
    // decode rotary encoder, setup for DMX address
    // only active, when jogdail is pressed
    // DMX address stored in eeprom on release in main loop
    if (KEY_PRESSED) {
        enc_new = 0;
        if( PHASE_A ) enc_new = 3;
        if( PHASE_B ) enc_new ^= 1;             // convert gray to binary
        enc_diff = enc_last - enc_new;          // difference last - new
        if( enc_diff & 1 ){                     // bit 0 = value (1)
            enc_last   = enc_new;               // store new as next last
            enc_delta += (enc_diff & 2) - 1;    // bit 1 = direction (+/-)
            if (enc_delta < 0)  enc_delta = 0;
            if (enc_delta > 84) enc_delta = 84;
        }     
    }
}

// Timer 1 Output COMPARE A Interrupt

ISR(TIMER1_COMPA_vect) {
 77a:  1f 92         push  r1
 77c:  0f 92         push  r0
 77e:  0f b6         in  r0, 0x3f  ; 63
 780:  0f 92         push  r0
 782:  11 24         eor  r1, r1
 784:  2f 93         push  r18
 786:  3f 93         push  r19
 788:  4f 93         push  r20
 78a:  5f 93         push  r21
 78c:  6f 93         push  r22
 78e:  8f 93         push  r24
 790:  9f 93         push  r25
 792:  af 93         push  r26
 794:  bf 93         push  r27
 796:  ef 93         push  r30
 798:  ff 93         push  r31

    static uint8_t pwm_cnt, slow_cnt;
    ut_t tmp;
    int8_t enc_new, enc_diff;           // encoder stuff

    OCR1A   += isr_ptr->time[pwm_cnt];
 79a:  40 91 88 00   lds  r20, 0x0088
 79e:  50 91 89 00   lds  r21, 0x0089
 7a2:  e0 91 01 01   lds  r30, 0x0101
 7a6:  f0 91 02 01   lds  r31, 0x0102
 7aa:  60 91 09 01   lds  r22, 0x0109
 7ae:  26 2f         mov  r18, r22
 7b0:  30 e0         ldi  r19, 0x00  ; 0
 7b2:  22 0f         add  r18, r18
 7b4:  33 1f         adc  r19, r19
 7b6:  e2 0f         add  r30, r18
 7b8:  f3 1f         adc  r31, r19
 7ba:  80 81         ld  r24, Z
 7bc:  91 81         ldd  r25, Z+1  ; 0x01
 7be:  48 0f         add  r20, r24
 7c0:  59 1f         adc  r21, r25
 7c2:  50 93 89 00   sts  0x0089, r21
 7c6:  40 93 88 00   sts  0x0088, r20
    tmp.d32  = isr_ptr->mask[pwm_cnt];
 7ca:  e0 91 01 01   lds  r30, 0x0101
 7ce:  f0 91 02 01   lds  r31, 0x0102
 7d2:  22 0f         add  r18, r18
 7d4:  33 1f         adc  r19, r19
 7d6:  e2 0f         add  r30, r18
 7d8:  f3 1f         adc  r31, r19
 7da:  df 01         movw  r26, r30
 7dc:  da 96         adiw  r26, 0x3a  ; 58
 7de:  92 ad         ldd  r25, Z+58  ; 0x3a
 7e0:  11 96         adiw  r26, 0x01  ; 1
 7e2:  3c 91         ld  r19, X
 7e4:  11 97         sbiw  r26, 0x01  ; 1
 7e6:  12 96         adiw  r26, 0x02  ; 2
 7e8:  2c 91         ld  r18, X
 7ea:  12 97         sbiw  r26, 0x02  ; 2
 7ec:  13 96         adiw  r26, 0x03  ; 3
 7ee:  4c 91         ld  r20, X
 7f0:  9f 60         ori  r25, 0x0F  ; 15
 7f2:  20 6f         ori  r18, 0xF0  ; 240

    if (pwm_cnt == 0) {                 // set ports at begin of PWM
 7f4:  66 23         and  r22, r22
 7f6:  99 f4         brne  .+38       ; 0x81e <__vector_13+0xa4>
        PORTD = tmp.ary[0] | 0x0F;      // PD0-3 no change
 7f8:  9b b9         out  0x0b, r25  ; 11
        PORTC = tmp.ary[1];
 7fa:  38 b9         out  0x08, r19  ; 8
        PORTB = tmp.ary[2] | 0xF0;      // PB4-7 no change
 7fc:  25 b9         out  0x05, r18  ; 5
        PORTA = tmp.ary[3];
 7fe:  42 b9         out  0x02, r20  ; 2
        pwm_cnt++;
 800:  91 e0         ldi  r25, 0x01  ; 1
 802:  90 93 09 01   sts  0x0109, r25
        slow_cnt++;
 806:  80 91 08 01   lds  r24, 0x0108
 80a:  8f 5f         subi  r24, 0xFF  ; 255
 80c:  80 93 08 01   sts  0x0108, r24
        if (slow_cnt == 10) {           // 100ms timer
 810:  8a 30         cpi  r24, 0x0A  ; 10
 812:  f1 f4         brne  .+60       ; 0x850 <__vector_13+0xd6>
            slow_cnt=0;
 814:  10 92 08 01   sts  0x0108, r1
            flag_100ms=1;               // trigger lcd refresh
 818:  90 93 bb 01   sts  0x01BB, r25
 81c:  19 c0         rjmp  .+50       ; 0x850 <__vector_13+0xd6>
        }
    }
    else {                              // clear ports
        PORTD &= (tmp.ary[0] | 0x0F);       
 81e:  8b b1         in  r24, 0x0b  ; 11
 820:  98 23         and  r25, r24
 822:  9b b9         out  0x0b, r25  ; 11
        PORTC &= tmp.ary[1];
 824:  88 b1         in  r24, 0x08  ; 8
 826:  83 23         and  r24, r19
 828:  88 b9         out  0x08, r24  ; 8
        PORTB &= tmp.ary[2] | 0xF0;
 82a:  85 b1         in  r24, 0x05  ; 5
 82c:  28 23         and  r18, r24
 82e:  25 b9         out  0x05, r18  ; 5
        PORTA &= tmp.ary[3];
 830:  82 b1         in  r24, 0x02  ; 2
 832:  84 23         and  r24, r20
 834:  82 b9         out  0x02, r24  ; 2
                                
        if (pwm_cnt == pwm_cnt_max) {
 836:  80 91 00 01   lds  r24, 0x0100
 83a:  68 17         cp  r22, r24
 83c:  31 f4         brne  .+12       ; 0x84a <__vector_13+0xd0>
            pwm_sync = 1;               // update now possible
 83e:  81 e0         ldi  r24, 0x01  ; 1
 840:  80 93 ba 01   sts  0x01BA, r24
            pwm_cnt=0;
 844:  10 92 09 01   sts  0x0109, r1
 848:  03 c0         rjmp  .+6        ; 0x850 <__vector_13+0xd6>
        }
        else pwm_cnt++;
 84a:  6f 5f         subi  r22, 0xFF  ; 255
 84c:  60 93 09 01   sts  0x0109, r22
    }
    
    // decode rotary encoder, setup for DMX address
    // only active, when jogdail is pressed
    // DMX address stored in eeprom on release in main loop
    if (KEY_PRESSED) {
 850:  49 99         sbic  0x09, 1  ; 9
 852:  24 c0         rjmp  .+72       ; 0x89c <__vector_13+0x122>
        enc_new = 0;
        if( PHASE_A ) enc_new = 3;
 854:  4b 9b         sbis  0x09, 3  ; 9
 856:  02 c0         rjmp  .+4        ; 0x85c <__vector_13+0xe2>
 858:  23 e0         ldi  r18, 0x03  ; 3
 85a:  01 c0         rjmp  .+2        ; 0x85e <__vector_13+0xe4>
 85c:  20 e0         ldi  r18, 0x00  ; 0
        if( PHASE_B ) enc_new ^= 1;             // convert gray to binary
 85e:  4a 9b         sbis  0x09, 2  ; 9
 860:  02 c0         rjmp  .+4        ; 0x866 <__vector_13+0xec>
 862:  81 e0         ldi  r24, 0x01  ; 1
 864:  28 27         eor  r18, r24
        enc_diff = enc_last - enc_new;          // difference last - new
 866:  90 91 0a 01   lds  r25, 0x010A
 86a:  92 1b         sub  r25, r18
        if( enc_diff & 1 ){                     // bit 0 = value (1)
 86c:  90 ff         sbrs  r25, 0
 86e:  16 c0         rjmp  .+44       ; 0x89c <__vector_13+0x122>
            enc_last   = enc_new;               // store new as next last
 870:  20 93 0a 01   sts  0x010A, r18
            enc_delta += (enc_diff & 2) - 1;    // bit 1 = direction (+/-)
 874:  80 91 be 01   lds  r24, 0x01BE
 878:  81 50         subi  r24, 0x01  ; 1
 87a:  92 70         andi  r25, 0x02  ; 2
 87c:  89 0f         add  r24, r25
 87e:  80 93 be 01   sts  0x01BE, r24
            if (enc_delta < 0)  enc_delta = 0;
 882:  80 91 be 01   lds  r24, 0x01BE
 886:  87 ff         sbrs  r24, 7
 888:  02 c0         rjmp  .+4        ; 0x88e <__vector_13+0x114>
 88a:  10 92 be 01   sts  0x01BE, r1
            if (enc_delta > 84) enc_delta = 84;
 88e:  80 91 be 01   lds  r24, 0x01BE
 892:  85 35         cpi  r24, 0x55  ; 85
 894:  1c f0         brlt  .+6        ; 0x89c <__vector_13+0x122>
 896:  84 e5         ldi  r24, 0x54  ; 84
 898:  80 93 be 01   sts  0x01BE, r24
        }     
    }
}
 89c:  ff 91         pop  r31
 89e:  ef 91         pop  r30
 8a0:  bf 91         pop  r27
 8a2:  af 91         pop  r26
 8a4:  9f 91         pop  r25
 8a6:  8f 91         pop  r24
 8a8:  6f 91         pop  r22
 8aa:  5f 91         pop  r21
 8ac:  4f 91         pop  r20
 8ae:  3f 91         pop  r19
 8b0:  2f 91         pop  r18
 8b2:  0f 90         pop  r0
 8b4:  0f be         out  0x3f, r0  ; 63
 8b6:  0f 90         pop  r0
 8b8:  1f 90         pop  r1
 8ba:  18 95         reti

Der wesentliche Ausschnitt ist der hier

    if (pwm_cnt == 0) {                 // set ports at begin of PWM
 7f4:  66 23         and  r22, r22
 7f6:  99 f4         brne  .+38       ; 0x81e <__vector_13+0xa4>
        PORTD = tmp.ary[0] | 0x0F;      // PD0-3 no change
 7f8:  9b b9         out  0x0b, r25  ; 11
        PORTC = tmp.ary[1];
 7fa:  38 b9         out  0x08, r19  ; 8
        PORTB = tmp.ary[2] | 0xF0;      // PB4-7 no change
 7fc:  25 b9         out  0x05, r18  ; 5
        PORTA = tmp.ary[3];
 7fe:  42 b9         out  0x02, r20  ; 2
        pwm_cnt++;
 800:  91 e0         ldi  r25, 0x01  ; 1
 802:  90 93 09 01   sts  0x0109, r25

Sieht recht optimal aus.

[Michael A. (micha54)]

A. K. schrieb:
> Peter II schrieb:
>> was macht das
>> eor  r19, r19
>> für einen sinn?
>
> Bei non-volatile lhs entfallen mov und eor.

Das versteh ich nicht.

@Falk: mir fehlt in Deinem Posting noch das Hexfile ;-)

Ok, ich habs verstanden und ausprobiert, das Union hat gewonnen.

Allerdings war -Os nix, weil dann meine inline functions per call 
aufgerufen werden. s=size und nicht s=superefficient.

Zur Zeit nehme ich -Os und #defines - Blöcke statt functions, damit 
läufts wie gewünscht.

Gruß,
Michael

[Peter II (Gast)]

Michael Appelt schrieb:
> Allerdings war -Os nix, weil dann meine inline functions per call
> aufgerufen werden. s=size und nicht s=superefficient.

dann verwende always_inline

[(prx) A. K. (prx)]

Michael Appelt schrieb:
>> Bei non-volatile lhs entfallen mov und eor.
>
> Das versteh ich nicht.

"lhs" = left hand side, und zwar hier von der Zuweisung.

Der Code mit dem EOR entsteht bei
*(volatile uint8_t *)ptr = adr >> 8;
aber nicht bei
*(uint8_t *)ptr = adr >> 8;