Spinnt der Compiler?

[Peter Z. (Gast)]

Hallo allerseits,
ich programmiere mit dem Atmel Studio 6.1 auf einem ATtiny84.
Man muss 4 Parameter eingeben.
Diese Routine funktioniert, siehe Photo-Beweis

if(Taste == down)
{
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
  Nr++;
  Nr &= 0x03;
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
}
if(Taste == up)
{
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
  Nr--;
  Nr &= 0x03;
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
}

Diese Routine habe ich daraus vereinfacht,
sollte eigentlich das gleiche machen,
tut sie aber nicht, die Markierung der Zahlen bleibt!

if((Taste == up) || (Taste == down))
{
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
  if(Taste == up)   Nr--;
  if(Taste == down) Nr++;
  Nr &= 0x03;
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
}

Wo mag der Fehler liegen?
Spinnt der Compiler oder habe ich etwas übersehen?

[sebi707 (Gast)]

Den Code hast du schon richtig zusammengefasst (ich gehe davon aus, dass 
"up" und "down" unterschiedlich definiert sind sonst gibt es tatsächlich 
unterschiede). Ich glaube kaum, dass es am Compiler liegt. Eher vermute 
ich einen Fehler in anderem Code.

[132 (Gast)]

Peter Zz schrieb:
> Spinnt der Compiler oder habe ich etwas übersehen?

Die Compiler haben selten Bugs ... die sitzen in 99,999% der Fälle vor 
dem Bildschirm.

Peter Zz schrieb:
> Wo mag der Fehler liegen?

Peter Zz schrieb:
> if((Taste == up) || (Taste == down))
> {
>   set_pos(Nr,60,absolut);
>   LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
>   if(Taste == up)   Nr--;
>   if(Taste == down) Nr++;


Du liest "Taste" mehrfach ein. Darin dürfte der Hund begraben liegen. 
Das ist ein gerne gemachter Fehler. Taste einmal einlesen z.B. in 
Taste_Temp und dann damit weiter arbeiten. Evtl ändert sich (z.B. auch 
durch prellen) der Zustand der Taste nachdem du in das
> if((Taste == up) || (Taste == down))
eingetaucht bist und ist dann bei
>   if(Taste == up)   Nr--;
>   if(Taste == down) Nr++;
schon wieder anderst.

[Peter Z. (Gast)]

132 schrieb:
> Du liest "Taste" mehrfach ein. Darin dürfte der Hund begraben liegen.

Nö:

  Taste = get_key();
  if(Taste_alt == keine_Taste) // Entprellung
   {


   //hier steht der Code


   }
  Taste_alt = Taste;

Nur einmal lesen!

enum{keine_Taste,up,down,rechts,links,Enter};
//*********************************************************************

      //hier steht auch Code der jetzt nicht interressiert

//*********************************************************************
unsigned char get_key(void)
{
  unsigned short int adc_wert = get_adc(2);
  if((adc_wert >= 140) && (adc_wert <= 200)) return(links);
  if((adc_wert >= 310) && (adc_wert <= 370)) return(down);
  if((adc_wert >= 480) && (adc_wert <= 540)) return(rechts);
  if((adc_wert >= 650) && (adc_wert <= 710)) return(up);
  if((adc_wert >= 820) && (adc_wert <= 880)) return(Enter);
  return(keine_Taste);
}
//*********************************************************************

Siehe Schaltplan

[Εrnst B. (ernst)]

Peter Zz schrieb:
> return(links);

Tut jetzt nix zur Sache, aber die Klammern bei return sind unnötig und 
kontraintuitiv.

"return" ist ein Operator, und keine Funktion.

return(i) + 1;

macht dasselbe wie

return i+1;

[Frank M. (ukw) (Moderator)]

Da hätte ich auch noch was. Ein "else" vor den entsprechenden 
if-Statements können zu einer weiteren Optimierung des ausführbaren 
Codes führen.

[Karl H. (kbuchegg)]

Peter Zz schrieb:

> Spinnt der Compiler oder habe ich etwas übersehen?

ALso ich seh jetzt auch nichts, was den Effekt erklären könnte.

Wenn du noch immer im Dunkeln tappst, dann geh in kleinen Schritten vor.

Erst mal wieder alles zurück auf Anfang

if(Taste == down)
{
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
  Nr++;
  Nr &= 0x03;
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
}
if(Taste == up)
{
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
  Nr--;
  Nr &= 0x03;
  set_pos(Nr,60,absolut);
  LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
}

wenn das noch klappt, dann kleine MOdifikationen.
Erste MOdifikation
ein gemeinsames 'if' rundherum legen

if( Taste == down || Taste == up )
{
  if(Taste == down)
  {
    set_pos(Nr,60,absolut);
    LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
    Nr++;
    Nr &= 0x03;
    set_pos(Nr,60,absolut);
    LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
  }
  if(Taste == up)
  {
    set_pos(Nr,60,absolut);
    LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);
    Nr--;
    Nr &= 0x03;
    set_pos(Nr,60,absolut);
    LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0xFFFF);
  }
}

das dürfte jetzt noch nichts geändert haben. Aber 'dürfte' ist nicht 
'hat nicht'. Also ist testen angesagt.

Wenn sich tatsächlich nichts verändert hat, dann fängst du an, in 
einzelnen Schritten den gemeinsamen Code aus den beiden if rauszuziehen. 
Immer nur 1 Anweisung nach der anderen. Und nach jeder Änderung: testen.

Das muss sich ja finden lassen, was da los ist.

[Peter Z. (Gast)]

Habe jetzt einiges in die Funktion

void Parameter_anzeigen(uint8_t Markierung)

gepackt.

Jetzt auf einmal geht folgendes:

if((Taste == down) || (Taste == up))
{
  Parameter_anzeigen(nicht_markiert);
  if(Taste == down) Nr = (Nr + 1) & 0x03;
  if(Taste == up)   Nr = (Nr - 1) & 0x03;
  Parameter_anzeigen(markiert);
}

Vielleicht hatte ich vorher den Compiler durch die schiere Menge an
Übergabewerten an die Funktion

LCD_Anzeige_Zahl(klein,Zahl[Nr],Stellen[Nr],Komma[Nr],0x0000);

verwirrt???

[Kaj (Gast)]

Peter Zz schrieb:
> Vielleicht hatte ich ... den Compiler durch die schiere Menge an
> Übergabewerten ... verwirrt???
Von welcher schieren Menge sprichst du? Ich seh da 5 Parameter, und?
Hättest du da jetzt 500 Parameter, würd ich sagen:
Ja..., gut, wird langsam einbisschen unübersichtlich, aber auch das 
juckt den Compiler nicht.

Hast du Compileroptimierung eingeschaltet? Wenn ja, welcher Level?
Hast du vielleicht einmal im Debug und einmal im Release compiliert?
Benutzt du den C oder den C++ Compiler? Hast du immer den selben 
Compiller benutzt? Zwischen durch irgendwelche Compilerflags geändert?

Ganz nebenbei:
Peter Zz schrieb:
> 132 schrieb:
>> Du liest "Taste" mehrfach ein. Darin dürfte der Hund begraben liegen.
>
> Nö:  Taste = get_key();
>   if(Taste_alt == keine_Taste) // Entprellung
>    {
>
>    //hier steht der Code
>
>    }
>   Taste_alt = Taste;
> Nur einmal lesen!
Nur einmal mitdenken!
Das kann hier keiner riechen, wenn du sowas nicht postest!

Peter Zz schrieb:
> Diese Routine funktioniert, siehe Photo-Beweis
Fällt mir schwer von dem bisschen Code auf das Photo oder umgekehrt zu 
schließen.

[Karl H. (kbuchegg)]

Peter Zz schrieb:

> Vielleicht hatte ich vorher den Compiler durch die schiere Menge an
> Übergabewerten an die Funktion

Sehr viel wahrscheinlicher ist es, dass du noch irgendwo anders in 
deinem Programm mindestens einen Fehler hast.

Sorry. Aber das ist so. Die "Hoffnung", das der Compiler fehlerhaft ist, 
ist in mehr als 99% aller Fälle unbegründet. Es ist wesentlich (ganz 
groß geschrieben) wahrscheinlicher, das du einen Programmfehler hast. 
Der muss noch nicht mal in dieser Funktion sitzen. Der muss noch nicht 
mal irgendwas mit dem beobachteten Symptom zu tun haben.

D.h. um es klipp und klar zu sagen: Du hast sehr wahrscheinlich noch 
mindestens einen Fehler im Programm, der jetzt nur darauf wartet, im 
ungünstigsten Moment zuzuschlagen. Durch die Programmänderung hast du 
die Auswirkungen des Fehlers in irgendeinen anderen Codebereich 
verschoben.