Optimierung Fehlerhaft?

[Stefan R. (stefanrau)]

Hallo ich bin hier fast am verzweifeln, ich habe hier ein Programm, bei 
dem der Compiler einen wichtigen wert wegoptimiert, Wie kann ich das 
Verhindern?

C-Code
char adcwertermittlung(unsigned char zeit_art) 
{    
      //Fehler: zeit_art ist immer 0??? da wegoptimiert
  
    
    adcteiler=1;
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC))  
    adc_ergebnis = ADCH;
    if (zeit_art==MINUTEN)
      {
      adcteiler=4;
      }
    if (zeit_art==STUNDEN)
      {
      adcteiler=10;
      }      
    adc_ergebnis=adc_ergebnis/adcteiler;
    
    if (adc_ergebnis>zeit_art)
      {
      adc_ergebnis = zeit_art;
      }      
    return adc_ergebnis;
    
}

Die Variable zeit_art wird immer wegotimiert, auch

C-Code
char adcwertermittlung(volatile unsigned char zeit_art)

Hat nichts geholfen.
Wer weiß Rat?

VG Stefan

[Peter (Gast)]

Der Wert wird wohl in einem Register landen und nicht in einer 
gesonderten Variable.
Das kannst Du dir im Listing File genauer ansehen.

Der Wert an sich sollte bei der Abfrage "if(zeit_art==MINUTEN)"
richtig ausgewertet werden.

[Julian B. (julinho)]

Poste Doch mal den compilierten Assembler-Code, dann sind wir alle 
schlauer!!!

[Stefan R. (stefanrau)]

Ich habe jetzt den Code noch mal so zusammen genommen, wie ich Ihn 
Ursprünglich hatte.
Ich muss jetzt noch mal korrigieren, der Code Funktioniert beim 
Debuggen, mit und ohne Optimierung, nur wenn ich alles auf den uC 
spiele, wird die letzte Abfrage nicht ausgeführt.
Ich habe jetzt mal alles Angehängt.

VG Stefan

[Stefan R. (stefanrau)]

Hier noch der passende Assembler Code:

00000250 <adcwertermittlung>:
 250:  28 2f         mov  r18, r24
 252:  81 e0         ldi  r24, 0x01  ; 1
 254:  80 93 02 01   sts  0x0102, r24
 258:  80 91 7a 00   lds  r24, 0x007A
 25c:  80 64         ori  r24, 0x40  ; 64
 25e:  80 93 7a 00   sts  0x007A, r24
 262:  04 c0         rjmp  .+8        ; 0x26c <adcwertermittlung+0x1c>
 264:  80 91 79 00   lds  r24, 0x0079
 268:  80 93 0b 01   sts  0x010B, r24
 26c:  80 91 7a 00   lds  r24, 0x007A
 270:  86 fd         sbrc  r24, 6
 272:  f8 cf         rjmp  .-16       ; 0x264 <adcwertermittlung+0x14>
 274:  2c 33         cpi  r18, 0x3C  ; 60
 276:  11 f4         brne  .+4        ; 0x27c <adcwertermittlung+0x2c>
 278:  84 e0         ldi  r24, 0x04  ; 4
 27a:  03 c0         rjmp  .+6        ; 0x282 <adcwertermittlung+0x32>
 27c:  28 31         cpi  r18, 0x18  ; 24
 27e:  19 f4         brne  .+6        ; 0x286 <adcwertermittlung+0x36>
 280:  8a e0         ldi  r24, 0x0A  ; 10
 282:  80 93 02 01   sts  0x0102, r24
 286:  60 91 02 01   lds  r22, 0x0102
 28a:  8d ef         ldi  r24, 0xFD  ; 253
 28c:  0e 94 83 01   call  0x306  ; 0x306 <__udivmodqi4>
 290:  80 93 0b 01   sts  0x010B, r24
 294:  28 17         cp  r18, r24
 296:  10 f4         brcc  .+4        ; 0x29c <adcwertermittlung+0x4c>
 298:  20 93 0b 01   sts  0x010B, r18
 29c:  80 91 0b 01   lds  r24, 0x010B
 2a0:  08 95         ret

und dazu noch mal den C-Code

C-Code
char adcwertermittlung(unsigned char zeit_art) 
{    
  
    adcteiler=1;
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC))  
    adc_ergebnis = ADCH;
    adc_ergebnis = 253;
    if (zeit_art==MINUTEN)adcteiler=4;
      
    if (zeit_art==STUNDEN)adcteiler=10;      
    
    adc_ergebnis=adc_ergebnis/adcteiler;
    
    if (adc_ergebnis>zeit_art)adc_ergebnis = zeit_art;// Fehler: Befehl nach Klammer wird nicht ausgeführt. 
    return adc_ergebnis;
    
}

[Jörg G. (joergderxte)]

Fehlt da nicht ein Semikolon?

while (ADCSRA & (1<<ADSC))  
    adc_ergebnis = ADCH;

"Solange ADSC gesetzt ist, lese ADCH"??

[Peter II (Gast)]

Hallo,
was dein code ein wenig schwer zu lesen machst ist, das du alle 
variabeln oben deklariert hast.

adc_ergebnis wird nur in adcwertermittlung verwendet, warum dann nicht 
dort deklarieren?

[Helfer (Gast)]

>  294:  cp  r18, r24      Vergleiche adc_ergebnis mit zeit_art
>  296:  brcc  .+4         Springe zu #29c wenn adc_ergebnis <= zeit_art
>  298:  sts  0x010B, r18  adc_ergebnis = zeit_art;
>  29c:  lds  r24, 0x010B  return adc_ergebnis;

[Peter D. (peda)]

Stefan Rau schrieb:
> Hier noch der passende Assembler Code:

Sieht doch alles korrekt compiliert aus.

Nur warum zwingst Du den Compiler, alles mit globalen Variablen zu 
rechnen?
Das erzeugt doch nur unnützten Code (die ganzen LDS/STS).


Peter

[willibald (Gast)]

Stefan Rau schrieb:
> if (adc_ergebnis>zeit_art)adc_ergebnis = zeit_art;
> // Fehler: Befehl nach Klammer wird nicht ausgeführt.

Der Befehl wird dann übersprungen, wenn adc_ergebnis kleiner oder gleich 
zeit_art ist. Welche Werte haben die Variablen denn an der Stelle?

Stefan Rau schrieb:
> nur wenn ich alles auf den uC
> spiele, wird die letzte Abfrage nicht ausgeführt.

Woran genau erkennst du das?

Und was wird nicht ausgeführt, die ganze if-Abfrage oder die vom if 
abhängige Zuweisung? Deine Beschreibungen sind hier nicht eindeutig.

[Stefan R. (stefanrau)]

@Jörg G
Du hast Recht. habe es korrigiert.

@PeterII
Da es nicht funtioniert hat habe ich angefangen alles zu ändern und habe 
auch die Variablen rausgeholt.

@Helfer
zum Glück mal jemand der Assembler erklärt.

@Peter Dannecker
Siehe PeterII

Die Frage aber bleibt, warum funktioniert das nicht auf den uC?
Habe den uC auch noch mal extra gelöscht. Ändert sich aber nichts.
Auch noch mal das Hex File gelöscht, Pfade geprüft, ändert sich auch 
nichts

Hier noch mal den C Code

C-Code
#define STUNDEN 24
#define MINUTEN 60

char adcwertermittlung(unsigned char zeit_art) 
{    
      unsigned char adc_ergebnis;
    unsigned char adcteiler=1;
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));  
    adc_ergebnis = ADCH;
  
    if (zeit_art==MINUTEN)adcteiler=4;
      
    if (zeit_art==STUNDEN)adcteiler=10;      
    
    adc_ergebnis=adc_ergebnis/adcteiler;
    
    if (adc_ergebnis>zeit_art)adc_ergebnis = zeit_art;// Fehler: Befehl nach Klammer wird nicht ausgeführt. Da wegoptimiert.      
    return adc_ergebnis;
}

und der passende ASMCode

AVR-Assembler-Code
00000250 <adcwertermittlung>:
 250:  28 2f         mov  r18, r24
 252:  80 91 7a 00   lds  r24, 0x007A
 256:  80 64         ori  r24, 0x40  ; 64
 258:  80 93 7a 00   sts  0x007A, r24
 25c:  80 91 7a 00   lds  r24, 0x007A
 260:  86 fd         sbrc  r24, 6
 262:  fc cf         rjmp  .-8        ; 0x25c <adcwertermittlung+0xc>
 264:  80 91 79 00   lds  r24, 0x0079
 268:  2c 33         cpi  r18, 0x3C  ; 60
 26a:  21 f0         breq  .+8        ; 0x274 <adcwertermittlung+0x24>
 26c:  28 31         cpi  r18, 0x18  ; 24
 26e:  21 f0         breq  .+8        ; 0x278 <adcwertermittlung+0x28>
 270:  61 e0         ldi  r22, 0x01  ; 1
 272:  03 c0         rjmp  .+6        ; 0x27a <adcwertermittlung+0x2a>
 274:  64 e0         ldi  r22, 0x04  ; 4
 276:  01 c0         rjmp  .+2        ; 0x27a <adcwertermittlung+0x2a>
 278:  6a e0         ldi  r22, 0x0A  ; 10
 27a:  0e 94 75 01   call  0x2ea  ; 0x2ea <__udivmodqi4>
 27e:  28 17         cp  r18, r24
 280:  08 f4         brcc  .+2        ; 0x284 <adcwertermittlung+0x34>
 282:  82 2f         mov  r24, r18
 284:  08 95         ret

[Stefan R. (stefanrau)]

Der die Variable ADCergebnis nimmt nach dem Auslesen des ADC einen Wert 
zwischen 0 und 255 an, in dem Beispiel hat er den Wert 253.

Die Rückgabe gebe ich auf einem Display aus.
Die Funktion wird mit
adc_reuckwert=(int)adcwertermittlung(MINUTEN); in Main aufgerufen.

Wenn ich nun an dem Poti drehen, der an dem ADC sitzt, den bewegt sich 
der Wert zwischen 0 und 74, sollte aber zwischen 0 und 60 sein. Da ja in 
der Abfrage steht:
Zeit Art ist MINUTEN also 60

if (adc_ergebnis>zeit_art)adc_ergebnis = zeit_art;

Wenn ich den Code im Simulator ausführe, dann wird bei 253 60 
zurückgegeben.
Nach dem Laden auf den uC wird 74 ausgegeben.

[Karl H. (kbuchegg)]

>   ADCSRA |= (1 << ADEN) | (1 << ADSC) | (1 << ADIE);

Dein Programm schmiert ab, sobald der ADC fertig ist.
Man gibt NIEMALS einen Interrupt frei, für den man keine ISR hat.

[Helfer (Gast)]

> Die Frage aber bleibt, warum funktioniert das nicht auf den uC?

Wie prüfst du das? Vielleicht hast du beim Testen auf dem µC andere 
Eingangsbedingungen als im Simulator. Im Simulator macht der ADC 
"nix", d.h. du gibst ihm in der Simulation Daten vor. Auf dem µC ist das 
anders.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#ADC_.28Analog_Digital_Converter.29

"In der praktischen Anwendung wird man zum Programmstart den ADC erst 
einmal grundlegend konfigurieren und dann auf verschiedenen Kanälen 
messen. Diese beiden Dinge sollte man meist trennen, denn das 
Einschalten des ADC und vor allem der Referenzspannung dauert ein paar 
Dutzend Mikrosekunden. Ausserdem ist das erste Ergebnis nach dem 
Einschalten ungültig und muss verworfen werden."

Hast du das beachtet?

[Karl H. (kbuchegg)]

Jetzt gehst du mal als erstes her und machst hier, hinter diese Ausgabe

    lcd_setcursor(1,1);
    lcd_string(adc_string);

noch ein Leerzeichen drann, nicht dass dich die Ausgabe narrt.

Und dann: Du hast ein LCD. Das kannst du benutzen um dir 
Zwischenergebnisse ausgeben zu lassen.

[Rolf Magnus (Gast)]

Stefan Rau schrieb:
> itoa(adc_reuckwert,adc_string,8);

Hat es einen speziellen Grund, daß du dir den Wert in Basis 8 ausgeben 
läßt? 74 oktal sind übrigens genau 60 dezimal.

[Stefan R. (stefanrau)]

@Heinz @Helfer

den Interrupt habe ich rausgenommen. Und eine Abfrage zum verwerfen des 
ersten wertes duchgeführt.

ADMUX |= (1<<REFS0)|(1<<ADLAR);
  ADCSRA |= (1 << ADEN) | (1 << ADSC);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));
  result = ADCH;


Ich habe auch die Variable ADC Ergebnis in ein int geändert, da ich 
neuerdings werte von über 255 bekomme.

@Heinz die zweite
Wie Wo und wie soll ich ein Leerzeichen einfügen?

@Rolf
ja, ich habe die Diaplayansteuereung aus dem TUT genommen, ich wollte da 
jetzt auch nichts ändern, daher gebe ich alles als char aus.

@all
Ich habe jetzt noch ein paar Diplayausgaben integriert und bei der 
If-Abfrage die 60 hart kodiert.

und erhalte als Wert 334 67 67 hier der Code dazu
Anmerkung dazu: 334/4 sind 83 ??? kann der uC nicht rechnen? ;-)

C-Code

/*
Diese Routine liest den ADC Wert aus und gibt je nach aufgerufener Einheit den Stunden oder Sekundenwert zurück. 
Aufgerufener Wert 24 dibt den ADC Wert so aufgelöst, dass ein Wert zwischen 0-24 zurückgegeben wird.
bei 60 das gleiche.
Bei anderen Werten ist der Wert die Obergrenze des zurückgegebenen Wertes.
*/
char adcwertermittlung(unsigned char zeit_art) 
{    
      unsigned int adc_ergebnis;
    unsigned char adcteiler=1;
    char tempchar[8];
    
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));  
    adc_ergebnis = ADCH;
    //Diplay Ausgabe 1
    lcd_clear();
    itoa((int)adc_ergebnis,tempchar,8);
    lcd_string(tempchar);
    _delay_ms(700);
    
    if (zeit_art==MINUTEN)adcteiler=4;
      
    if (zeit_art==STUNDEN)adcteiler=10;      
    
    adc_ergebnis=adc_ergebnis/adcteiler;
    //Diplay Ausgabe 2
    lcd_clear();
    itoa((int)adc_ergebnis,tempchar,8);
    lcd_string(tempchar);
    _delay_ms(500);
    
    
    if (adc_ergebnis>60)adc_ergebnis = 60;// Fehler: Befehl nach Klammer wird nicht ausgeführt. 
    //Diplay Ausgabe 3
    lcd_clear();
    itoa((int)adc_ergebnis,tempchar,8);
    lcd_string(tempchar);
    _delay_ms(500);
    
    return adc_ergebnis;
    
}

[Karl H. (kbuchegg)]

Stefan Rau schrieb:

> und erhalte als Wert 334 67 67 hier der Code dazu
> Anmerkung dazu: 334/4 sind 83 ??? kann der uC nicht rechnen? ;-)

Doch er kann rechnen.
Aber du kannst nicht in unterschiedlichen Zahlensystemen denken.

Rolf hats gesehen
Beitrag "Re: Optimierung Fehlerhaft?"



    itoa((int)adc_ergebnis,tempchar,8);

Immer noch!
Die 8 als 3. Parameter sind nicht das, was du glaubst das es ist!
Doku zu itoa lesen!

[Stefan R. (stefanrau)]

Hallo Karl Heinz.

Danke für den Wink mit dem Baumstamm.... ich habe den Beitrag von Rolf 
nicht verstanden.Ich dachte der 3. Parameter wäre die Länge...
Jetzt kommt meine 60 so wie es soll.


Danke an alle.

VG Stefan