Mein AVR glaubt, (x == x) = 0!

[Julian E. (Gast)]

Hallo zusammen,

kann mir vielleicht jemand verraten, was an folgenden Zeilen schief 
gehen könnte?
( System: AVR ATMega8515 auf STK500 mit 16x2-Pollin-LCD an PORTA )

#include <avr/io.h>
#include <avr/interrupt.h>
#include "lcd.h"

typedef struct {
  uint8_t size;
  uint8_t data[10];
} buffer_t;

volatile buffer_t buffer;

int main( void ) {
   ...
}

ISR ( USART_RX_vect ) {
  ...
  lcd_command( 0b11000101 );   // Cursor Zeile 2, Zeichen 5
  print_hex( c );
  print_ascii( ' ' );
  print_hex( (SB0+SB1+buffer.size) );
  print_ascii( ' ' );
  print_ascii( '0' + (c == (SB0+SB1+buffer.size)) );
  if ( c == (SB0+SB1+buffer.size) )
    state = 4;
  ...
}

Das LCD zeigt mir dann z.B. |   34 34 0    | an und state=4 wird nicht 
erreicht. Nur warum ist
   ( c == (SB0+SB1+buffer.size) ) = 0
wenn offensichtlich gilt:
   c = (SB0+SB1+buffer.size) = 0x34
Was kann da schief laufen?

vielen Dank
lg Julian

[Karl H. (kbuchegg)]

Julian E. schrieb:

> wenn offensichtlich gilt:
>    c = (SB0+SB1+buffer.size) = 0x34

erklär mir bitte mal nur mit obigem Codeschnipsel, warum das 
offensichtlich sein soll!

Offensichtlich ist, dass das Low-Byte des Additionsergebnisses 34 
ergibt. Aber das sagt ja nichts darüber aus, was das Highbyte ergibt.


Wie groß ist SB0?
Wie groß ist SB1?
Wie gross ist buffer.size?

[Matthias L. (Gast)]

Wo kommt den c her? Und woher willst du wissen, dass state=4 nicht 
erreicht wird?

[Julian E. (Gast)]

Sorry, in der Eile und Aufregung hab ich glaub ich einiges vergessen, 
ich probiers nochmal:

#include <avr/io.h>
#include <avr/interrupt.h>
#include "lcd.h"

#define SB0 'S'
#define SB1 'Ü'

typedef struct {
  uint8_t size;
  uint8_t data[10];
} buffer_t;

volatile buffer_t buffer;

int main( void ) {
   ...
}

ISR ( USART_RX_vect ) {
  uint8_t c = UDR;
  ...
  lcd_command( 0b11000101 );   // Cursor Zeile 2, Zeichen 5
  print_hex( c );
  print_ascii( ' ' );
  print_hex( (SB0+SB1+buffer.size) );
  print_ascii( ' ' );
  print_ascii( '0' + (c == (SB0+SB1+buffer.size)) );
  if ( c == (SB0+SB1+buffer.size) )
    state = 4;
  ...
}

ich weiß dass, das Programm nicht weiter läuft an genau dieser stelle wo 
state=4 gesetzt wird. Das hab ich mit Displayausgaben nach und nach so 
ausgelotet^^ aber da ist ja eindeutig ein Fehler oder nicht?

[Klaus (Gast)]

Wie man anhand deines Codeschnipsels klar erkennen kann liegt es daran, 
dass c, SB0 und SB1 definiert sind als

crazy int c, SB0, SB1;

Dadurch ist der Compiler nicht länger an die klassische Mathematik 
gebunden und kann Operationen zu Gunsten undefinierter Ergebnisse 
optimieren.

[MaWin (Gast)]

Da du NATÜRLICH aus grenzenloser Faulheit nicht hinschreibst,
wie SB0 und SB1 definiert sind, kann man nur raten,
und macht sich als Antowrtender vermutlich die Arbeit umsonst.

Das kommt davon wenn man Antowrten kostenlos gibt,
du solltest zahlen, dann werden vielleicht deine Fragen besser.

Vermutlich ist SB0+SB1+buffer.size irgendwas wie 0x134,
also 0x134 <> 0x34.

Da du aber mit nur PrintHex die unteren 8 bits ausgibst,
bekommst du 0x34 und 0x34 angezeigt.

[Klaus (Gast)]

Aha! Also doch...

[Karl H. (kbuchegg)]

#define SB0 'S'
#define SB1 'Ü'

da brauch ich gar nicht mehr länger nachsehen.
Die ASCII COdes von 'S' und 'Ü' zusammengezählt ergeben nie und nimmer 
0x34

[Julian E. (Gast)]

MaWin schrieb:
> Vermutlich ist SB0+SB1+buffer.size irgendwas wie 0x134,
> also 0x134 <> 0x34.

ich habs grad mit folgendermaßen probiert und es läuft:

#include <avr/io.h>
#include <avr/interrupt.h>
#include "lcd.h"

#define SB0 'S'
#define SB1 'Ü'

typedef struct {
  uint8_t size;
  uint8_t data[10];
} buffer_t;

volatile buffer_t buffer;

int main( void ) {
   ...
}

ISR ( USART_RX_vect ) {
  uint8_t c = UDR;
  ...
  if ( c == (uint8_t)(SB0+SB1+buffer.size) )
    state = 4;
  ...
}

ich frage mich nur, warum mein Compiler da plötzlich etwas anderes als 
ein uint8_t draus macht... ich dachte er rechnet automatisch mit dem 
kleinst möglichen Datentyp und das ist in dem Fall (SB0,SB1,buffer.size 
sind alle uint8_t) ein uint8_t...

trotzdem DANKE ihr rettet meine Laune und meinen Abend ;)
1000 DANK

[Andreas B. (Gast)]

Tatsächlich kann SB0+SB1 (ergibt 303) alleine schon gar nicht mit 
uint8_t repräsentiert werden und dann wird ja dazu noch buffer.size 
aufaddiert…

c == (SB0+SB1+buffer.size)

ist also konstant false und der AVR hat (natürlich) recht.

[Karl H. (kbuchegg)]

Julian E. schrieb:

> ich frage mich nur, warum mein Compiler da plötzlich etwas anderes als
> ein uint8_t draus macht...

Weil er im Gegensatz zu dir die C-Regeln kennt.

In a nutshell:
Gerechnet wird immer mindestens im Zahlenbereich int


> ich dachte er rechnet automatisch mit dem kleinst möglichen Datentyp

Wenn schon, dann mit dem größeren der beiden an der Operation 
beteiligten. Und deine rechte Seite des Vergleichs hat nun mal Datentyp 
int.