Funkübertragung über uC

[Jens (Gast)]

Hallo,
ich bin relativ neu in dem Gebiet der Controllerprogrammierung und hätte 
da eine Frage.
Ich habe ein Modul angefertigt, welches die Signale über Bluetooth 
übertragen hat und diese wurden jeweils von einem uC ausgewertet.
Dieses Modul hat auch wunderbar funktioniert.
Nun habe ich das Bluetooth mModul gegen ein Funkmodul der Firma 
Radiometrix (RX2-433-14-5V bzw. TX2-433-14-5V) ausgetauscht.
Wenn ich nun versuche die signale zu senden, so springt der empfänger 
zwar in der Empfangsinterrupt jedoch kann ich die Signale nicht 
anzeigen, außer ein unkontrolliertes aublitzen der LEDs ist nichts zu 
sehen.

Nun meine Frage könnte dies mit der Baudrate zusammen hängen, denn diese 
ist noch auf den Werten des Bluetoothmoduls basierend.
Und zum zweiten kann ich meine signale einfach in einer bitfolge senden, 
oder muss ich diese irgendwie coderien?

Ich bin für jede Hilfe sehr Dankbar!

#include <avr/io.h>
#include <avr/interrupt.h>
#include <inttypes.h>


// Abfragemakro
//#define BLUETOOTH_STATUS_AKTIV() (!(PIND & _BV(PD2)))    // Abfrage Bluetooth-Signal
#define SCHALTER_LS()        (!(PIND & _BV(PD7)))  // Abfrage Schalter Lautsprecher eingeschaltet

// Aktionsmakro
#define ROTE_LED_AN()    { PORTC |=  _BV(PC3); }      // rote LED ein      -> 3.3V
#define ROTE_LED_AUS()    { PORTC &= ~_BV(PC3); }      // rote LED aus     -> 0V

#define GELBE_LED_AN()    { PORTC |=  _BV(PC1); }      // gelbe LED ein     -> 3.3V
#define GELBE_LED_AUS()    { PORTC &= ~_BV(PC1); }      // gelbe LED aus     -> 0V

#define GRUENE_LED_AN()    { PORTC |=  _BV(PC2); }      // grüne LED ein     -> 3.3V 
#define GRUENE_LED_AUS()   { PORTC &= ~_BV(PC2); }      // grüne LED aus     -> 0V

#define BLAUE_LED_AN()    { PORTC |=  _BV(PC0); }      // blaue LED ein     -> 0V
#define BLAUE_LED_AUS()   { PORTC &=  ~_BV(PC0); }      // blaue LED aus     -> 5V

#define LS_AN()        { PORTB |=  _BV(PB1); }      // grüne LED ein     -> 3.3V 
#define LS_AUS()         { PORTB &= ~_BV(PB1); }    // grüne LED aus     -> 0V

#define LED_LS_AN()      { PORTB |= _BV(PB0); }    // LED Lautsprecher an -->5V
#define LED_LS_AUS()      { PORTB &= ~_BV(PB0); }    // LED Lautsprecher aus --> 0V

#define RELAIS_AN()      { PORTD |= _BV(PD4); }    // Relais an -->5V
#define RELAIS_AUS()      { PORTD &= ~_BV(PD4); }    // Relais aus --> 0V

#define LEUCHT_ROT_AN()    { PORTD |= _BV(PD5); }    // Leuchtmodul "rot" an -->5V
#define LEUCHT_ROT_AUS()  { PORTD &= ~_BV(PD5); }    // Leuchtmodul "rot" aus --> 0V

#define LEUCHT_GRUEN_AN()    { PORTD |= _BV(PD6); }    // Leuchtmodul "grün" an -->5V
#define LEUCHT_GRUEN_AUS()    { PORTD &= ~_BV(PD6); }    // Leuchtmodul "grün" aus --> 0V

#define LEUCHT_BLAU_AN()    { PORTC |= _BV(PC4); }    // Leuchtmodul "blau" an -->5V
#define LEUCHT_BLAU_AUS()    { PORTC &= ~_BV(PC4); }    // Leuchtmodul "blau" aus --> 0V


//Variablen Deklaration
volatile uint8_t u8_blau = 0;                // Variable für die blaues Signal
volatile uint8_t u8_rot = 0;                // Variable für die rotes Signal
volatile uint8_t u8_gelb = 0;                // Variable für die gelbe LED
volatile uint8_t u8_gruen = 0;                // Variable für die grünes Signal
volatile uint8_t u8_Lautsprecher = 0;            // Variable für den Lautsprecher
volatile uint8_t u8_Empfang = 0;              // Empfangsdaten
volatile uint8_t u8_timer = 0;                // Taktzähler
volatile uint16_t u16_timer2 = 0;              // Tondauer "frei"
volatile uint16_t u16_timer1 = 0;              // Tondauer "Störung"
//volatile uint32_t u32_timer_bluetooth = 0;          // Timer für Bluetoothstatus
// Variable für die Tonausgabe "frei"
volatile uint16_t u8_Tonausgabe1 = 0;            
// Variable für die Tonausgabe "belegt"
volatile uint16_t u8_Tonausgabe2 = 0;  
// Variable, die den letzten Zustand von "gelb" speichert          
volatile uint8_t u8_letztes_gelb = 0;  
// Variable, welche angibt ob Bluetoothmodule verbunden          
volatile uint8_t u8_b_aktiv = 0;

// Initialisierung USART
//#define F_CPU 16000000ULL                  // Frequenz vom Mikrocontroller 16MHz
#define BAUD 9600UL                         // Baudrate 
#define UBRR_VAL ((F_CPU+BAUD*8)/(BAUD*16)-1)       // clever runden 
#define BAUD_REAL (F_CPU/(16*(UBRR_VAL+1)))         // Reale Baudrate 
#define BAUD_ERROR ((BAUD_REAL*1000)/BAUD)         // Fehler in Promille, 1000 = kein Fehler. 
#if ((BAUD_ERROR<990) || (BAUD_ERROR>1010))           
#error Systematischer Fehler der Baudrate grösser 1% und damit zu hoch! 
#endif 

// Funktionprototypen
void USART_Init( unsigned int ubrr);            // Prototyp initialisierung

// Hauptprogramm
int main(void)
{
  TCCR0B |= _BV(CS01) | _BV(WGM01);             // prescaler 1600000/64 = 15625
  OCR0A = 99;                            // 124 Schritte für 1ms
  TIMSK0 |= _BV(OCIE0B);                    // Freischaltung

  TCCR0A = _BV(WGM00);                      // PWM phase correct mode
  TCCR0B = _BV(CS10) | _BV(CS11);              // clock select clk/64
  ICR1 = 0xFF;                          // Endwert Counter

// OC0A als PWM-Port setzen
  TCCR1A |= _BV(COM0A1);
  OCR0A = 0;

// OC0B als PWM-Port setzen
  TCCR1B |= _BV(COM0B1);
  OCR0B = 0;

// Ausgänge
  DDRC |= _BV(PC0) | _BV(PC1) | _BV(PC2) | _BV(PC3);         // Alle Signallampen als Ausgänge deklariert
  PORTC &= ~(_BV(PC0) & _BV(PC1) & _BV(PC2) & _BV(PC3));      // Signallampen ausschalten -> definierter Zustand zu Beginn -> 0V

  DDRD |= _BV(PD5) | _BV(PD6) ;         // Alle LEDs des Leuchtmoduls als Ausgänge deklariert
  DDRC |= _BV(PC4);
  PORTD &= ~(_BV(PD5) & _BV(PD6));        // Alle LEDs des Leuchtmoduls -> definierter Zustand zu Beginn -> 0V
  PORTC &= ~(_BV(PC4));

  DDRB |= _BV(PB0) | _BV(PB1);                        // Lautsprecher und Lautsprecher-LED als Ausgang deklariert
  PORTB &= ~(_BV(PB0)| _BV(PB1));                      // definierter Zustand zu Beginn

  DDRD |= _BV(PD4);                        // Relais als Ausgang deklariert
  PORTD &= ~_BV(PD4);                      // definierter Zustand zu Beginn

// Eingänge
  DDRD &= ~(_BV(PD7));            // Schalter Lautsprecher als Eingang
  PORTD |= _BV(PD2) | _BV(PD7);      // Pull up aktiviert


// Funktionsaufruf Initialisierung Bluetooth
USART_Init(UBRR_VAL );

  sei();
//Endlosschleife
  while(1)
  {

// Funkmodule verbunden
    if ( u8_Empfang == 0b00001000 )           // Abfrage sind die Funkmodule verbunden
    {
      u8_blau = 1;                  // wenn "ja", schalte blaue LED an
    }
    else                        // wenn "nein"
    {
      u8_blau = 0;                  // schalte blaue LED aus
    }

// Rot empfangen
    if(u8_Empfang == 0b00000001)            // Abfrage "Störung" empfangen?
    {  
      u8_rot = 1;                    // wenn "ja" steuer rote LED an
    }
    else                        // wenn "nein"
    {  
      u8_rot = 0;                    // steuere rote LED nicht an
    }

// Gelb empfangen
    if(u8_Empfang == 0b00000010)            // Abfrage "Fräse in Betrieb" empfangen?
    {
      u8_gelb = 1;                  // wenn "ja" steuer gelbe LED an
    }
    else                        // wenn "nein"
    {
      u8_gelb = 0;                  // steuere grüne LED nicht an
    }

// Grün empfangen
    if(u8_Empfang == 0b00000100)            // Abfrage "Fräse frei" empfangen?
    {
      u8_gruen = 1;                  // wenn "ja" steuer grüne LED an
    }
    else                        // wenn "nein"
    {
      u8_gruen = 0;                  // steuere grüne LED nicht an
    }

    if ( u8_blau == 1 )                       
    {
      BLAUE_LED_AN();                  // Blaue LED an  
      RELAIS_AN();                    // Selbsthaltung ein                  
    }
    else                                
    {
      BLAUE_LED_AUS();                // Blaue LED aus
      RELAIS_AUS();                  // Selbsthaltung aus
    }

    if(u8_rot == 1)
    {
      ROTE_LED_AN();                  // Rote LED an
    }
    else
    {
      ROTE_LED_AUS();                  // Rote LED aus
    }

      if(u8_gelb == 1)
    {
      GELBE_LED_AN();                  // Gelbe LED an
    }
    else
    {
      GELBE_LED_AUS();                // Gelbe LED aus
    }

    if(u8_gruen == 1)
    {
      GRUENE_LED_AN();                // Grüne LED an
    }
    else
    {
      GRUENE_LED_AUS();                // Grüne LED aus
    }

  }
}

// Funktion USART Initialisierung
void USART_Init( unsigned int ubrr)        
{
//Set baud rate 
UBRR0 = ubrr;

//Enable receiver and transmitter 
UCSR0B = _BV(RXEN0)| _BV(TXEN0) | _BV(RXCIE0);        // Sender, Empfänger und Empfangsinterrupt
UCSR0C = _BV(UCSZ00)| _BV(UCSZ01);              // Format bestimmen 8 Datenbits 2 Stoppbits
}


//Empfangsinterrupt
ISR(USART_RX_vect)                      // wird ausgelöst, wenn Daten empfangen wurden
{
//  if (u8_b_aktiv == 1)                  // Abfrage, besteht Verbindung?
//  {
      u8_Empfang = UDR0;                  // empfangene Daten werden in "u8_Empfang" gespeichert
    GRUENE_LED_AN();
//  }
//  else                          // wenn keine Verbindung besteht schalte alle LEDs aus
//  {
//    u8_Empfang = 0b00000000;
//  }
}

[Edi R. (edi_r)]

Wenn ich das richtig sehe, schaltest Du die grüne LED ein, wenn ein 
Zeichen empfangen wurde, aber in der Hauptschleife wird die grüne LED 
sofort wieder ausgeschaltet, wenn das empfangene Byte nicht 0b00000100 
ist. Es könnte also durchaus mit der Baudrate zusammenhängen, weil bei 
einer falschen Baudrate die empfangenen Signale falsch interpretiert 
werden und deshalb nicht die erwarteten Werte ankommen.

[Jens (Gast)]

okay, jetzt bleibt grün an sprich er schein in den empfangsinterrupt zu 
springen, dies tut er aber obwohl der Sender gar nicht eingeschaltet ist 
...

[Edi R. (edi_r)]

Vielleicht empfängt der Empfänger trotzdem was, z. B. Rauschen. Ich 
kenne den Empfänger nicht.

[Jens (Gast)]

ja das selbe problem hab ich auch, hab den sender und empfänger so 
bekommen und auch nach mehrfacher suche nichts gefunden, bzw nichts 
gefunden indem jemand den shconeinmal benutzt hat

[Jens (Gast)]

hab nun die baudrate auf 4800 geändert und immernoch das selbe problem

[Edi R. (edi_r)]

Solange Du nicht die richtige Baudrate einstellst, wird sich auch 
nichts ändern. Die richtige Baudrate bekommst Du vielleicht aus dem 
Datenblatt heraus:

http://jp.ic-on-line. cn /IOL/datasheet/rx2-433-14-5v_4181122.pdf
(entferne die Leerzeichen vor und nach dem "cn".)

[Jens (Gast)]

das Datenblatt hab ich ja schon kann auch sein, dass meine Berechnung da 
nicht stimmt hab das über ne Software im Netz gemacht, weil ich nich 
wusste welche werte für UBBR am sinnvollsten sind

[Edi R. (edi_r)]

Ich hab mal kurz ins Datenblatt des Empfängers geschaut. Nachdem Du 
ursprünglich von einem Bluetooth-Modul geschrieben hast, bin ich davon 
ausgegangen, dass das Funkmodul ebenfalls die Daten via Protokoll 
überträgt und am Ausgang als V.24-Signal ausgibt. Dem ist offenbar nicht 
so, sondern das Sender/Empfängerpaar überträgt nur "dumm" einen 
logischen Zustand. Wenn man also beim Sender V.24 reinschickt, kommt 
beim Empfänger V.24 an. Folglich musst Du herausfinden, mit welcher 
Baudrate der Sender gefüttert wird, und diese Baudrate auch bei Deinem 
Programm einstellen. Sind das 9600 Baud? Falls ja: Wo ist F_CPU 
definiert? Wirklich mit dem richtigen Wert? (Die Zeile im angegebenen 
Programm ist auskommentiert.)

[Jens (Gast)]

die Zeile hab ich auskommentiert, da sonst eine Warnung im AVR auftritt, 
ich benutez einen ATMEGA168 und dazu einen 16MHz Quarz und habe die 
Baudrate bei beiden Programmen also bei der des Senders und des 
Empfängers zu beginn auf 9600 Baud gestellt und nun auf 4800 geändert 
gehabt wie gesagt ob der wert so korrekt ist weiß ich nicht

[Edi R. (edi_r)]

Welche Warnung kommt denn?

[Jens (Gast)]

../main.c:63:1: warning: "F_CPU" redefined
<command-line>: warning: this is the location of the previous definition

[Karl H. (kbuchegg)]

Jens schrieb:
> das Datenblatt hab ich ja schon kann auch sein, dass meine Berechnung da
> nicht stimmt hab das über ne Software im Netz gemacht, weil ich nich
> wusste welche werte für UBBR am sinnvollsten sind

Wenn du mit Baudraten unsicher bist, gibt es eine einfache Möglichkeit, 
das abzuklären:

Benutze ein Gerät von dem zu mit Sicherheit weißt, dass die Baudraten 
richtig gehandhabt wird. Zb einen PC.

Du hängst dein Funkmodem am PC an und startest ein Terminalprogram. Dann 
stellst du die Baudraten ein, die du in Verdacht hast (auf deutsch: du 
probierst einfach durch). An der Ausgabe des Terminalprogramm siehst du, 
wann du die richtige Baudrate hast. Damit weißt du schon mal, mit 
welcher Baudrate dein Sender sendet.

Dann hängst du deine µC Schaltung ebenfalls an den PC und benutzt wieder 
besagtes Terminalprogramm um deinem µC kontrolliert mit einer bestimmten 
Baudrate, die du am PC einstellst, zu füttern. An der Reaktion des µC 
erkennst du, ob du richtig liegst.

Funktioniert beides
  Empfangen vom Modem mit der Baudrate x
  Senden an den µC mit derselben Baudrate x
dann kannst du Funkmodem und µC zusammenschalten und alles müsste 
laufen.

[Jens (Gast)]

naja so einfach geht das nicht, da ich alles zusammen auf eine platine 
gelötet habe und über eine isp schnittstelle programmiere und alles in 
gehäusen untergebracht ist man muss das doch irgendwie berechnen können

[Edi R. (edi_r)]

Die Warnung sagt, dass in der Kommandozeile eine Frequenz angegeben ist. 
Wenn nicht 16 MHz angegeben ist, wird auch nicht die richtige Baudrate 
eingestellt. Mit welcher Entwicklungsumgebung arbeitest Du? AVRStudio?

[Jens (Gast)]

ja genau und da habe ich bei den configuration options bereits die 
passende frequenz eingestellt sowie bei den Fuses auch

[Edi R. (edi_r)]

Möglicherweise klappt ja auch die Übertragung zwischen Sender und 
Empfänger nicht, und der Empfänger gibt nur Rauschen aus. Kannst Du Dir 
den Ausgang des Empfängers am Oszilloskop anschauen, möglichst 
gleichzeitig mit dem Eingangssignal des Senders?

[Jens (Gast)]

da müsst ich mal suchen, ob ich irgendwo nen oszilloskop herbekommen 
könnte

[Karl H. (kbuchegg)]

Jens schrieb:
> naja so einfach geht das nicht, da ich alles zusammen auf eine platine
> gelötet habe und über eine isp schnittstelle programmiere und alles in
> gehäusen untergebracht ist man muss das doch irgendwie berechnen können

Na dann.
Viel Spass beim Stochern im Nebel

[Edi R. (edi_r)]

Was mir dazu eingefallen ist, haben wir abgeklärt, aber das hat ja 
nichts gebracht. Ich weiß nicht, ob das Signal wirklich richtig ankommt, 
und ich weiß nicht, mit welcher Baudrate der ATmega tatsächlich 
empfängt.

Jetzt musst Du den Fehler messtechnisch einkreisen, sonst ist es 
wirklich ein Stochern im Nebel.

[Jens (Gast)]

so oszilloskop läuft ich sende den richtigen Bitcode und empfange ihn 
auch, habe nun die Frequenz herunter gesetzt, da ich dachte, dass mein 
controller mit einer solchen Sendeflut nicht zurecht kommt und sende nun 
nur noch alle 100ms jedoch sende ich dann nicht nur ein signal sondern 3 
gleiche Signale hintereinander, was aber auch nichts ausmachen dürfte

[Edi R. (edi_r)]

Und am Ausgang des Empfängers kommt das gleiche an, das Du am Eingang 
des Senders reinschickst? Wenn ja: Wie groß ist die Baudrate der 
gesendeten Zeichen? Und stimmt das mit der Anzeige am Oszilloskop 
überein?

[Jens (Gast)]

ja stimmt alles habe ich berechnet.
Sprich die Module arbeiten beide einwnadfrei, ich bin nun soweit, dass 
ich vor meiner Nachricht eine Art code sende, um weitere Fehler 
ausschließen zu können.
Nun weiß ich nicht genau wie ich das beim empfänger verarbeite, wenn ich 
2 verschiedene bitfolgen habe, das senden funktioniert schoneinmal.

Ich möchte zuerst den code auswerten und sollte dieser richtig sein, 
will ich den zweiten Bitstrom auswerten.
Nur weiß ich halt ncht genau wie ich das anstellen soll,
ich stelle mal rein wie ich es bisher habe es scheint aber nicht zu 
funktionieren.

//Empfangsinterrupt
ISR(USART_RX_vect)                      // wird ausgelöst, wenn Daten empfangen wurden
{  
  u8_Empfang = UDR0;                  // empfangene Daten werden in "u8_Empfang" gespeichert
  if( u8_Empfang == 0b00101011)
  {
    u8_Code_empfangen = 1;
  }
  else
  {
    u8_Code_empfangen = 0;
  }
      
}

und dann frage ich den Variable u8_code_emfangen im Hauptprogramm 
zusätzlich ab

// Rot empfangen
    if(u8_Empfang == 0b00000001 && u8_Code_empfangen ==1)            // Abfrage "Störung" empfangen?
    {  
      u8_rot = 1;                    // wenn "ja" steuer rote LED an
    }
    else                        // wenn "nein"
    {  
  
      u8_rot = 0;                    // steuere rote LED nicht an
    }

[Jens (Gast)]

hab nochmal optimiert

//Empfangsinterrupt
ISR(USART_RX_vect)                      // wird ausgelöst, wenn Daten empfangen wurden
{  
//  u8_Empfang = UDR0;                  // empfangene Daten werden in "u8_Empfang" gespeichert
  if( UDR0 == 0b00101011)
  {
  u8_Empfang = UDR0;
    u8_Code_empfangen = 1;
  }
    
}

und

// Rot empfangen
    if(u8_Empfang == 0b00000001 && u8_Code_empfangen ==1)            // Abfrage "Störung" empfangen?
    {  
      u8_rot = 1;                    // wenn "ja" steuer rote LED an
      u8_Code_empfangen = 0;
    }
    else                        // wenn "nein"
    {  
  
      u8_rot = 0;                    // steuere rote LED nicht an
    }

[Karl H. (kbuchegg)]

Ich würde grundsätzlich das Empfangen vom Auswerten des Empfangenen 
trennen.
Die ISR ist nur dafür zuständig ein Byte von der UART zu holen und zb in 
einem Ringbuffer abzulegen.
Ob das Empfangene gültig ist, sehe ich mir dann bei der Auswertung zb in 
main() an.

ISR(USART_RX_vect)                      // wird ausgelöst, wenn Daten empfangen wurden
{  
//  u8_Empfang = UDR0;                  // empfangene Daten werden in "u8_Empfang" gespeichert
  if( UDR0 == 0b00101011)
  {
  u8_Empfang = UDR0;
    u8_Code_empfangen = 1;
  }
    
}

Das darfst du nicht tun. Du darfst UDR0 nur ein einziges mal pro Zeichen 
auslesen.

[Jens (Gast)]

alles klar danke =)

Und wie trenne ich dann die beiden daten voneinander?

[Jens (Gast)]

So habe nun meinen code abgesichert und die baudrate heruntergesetzt, 
damit alles deutlich und sauber übertragen wird seht auch alles danach 
aus, habe nun abgetestet, und mein microcontroller kann irgendiwe nichts 
mit den daten anfangen, sprich er nimmt den code nicht als den richtigen 
code war, hat jemand ne ahnun woran das liegen könnte?

[Karl H. (kbuchegg)]

Jens schrieb:
> So habe nun meinen code abgesichert und die baudrate heruntergesetzt,
> damit alles deutlich und sauber übertragen wird seht auch alles danach
> aus, habe nun abgetestet, und mein microcontroller kann irgendiwe nichts
> mit den daten anfangen, sprich er nimmt den code nicht als den richtigen
> code war, hat jemand ne ahnun woran das liegen könnte?

Ja. An deinem Programm

[Jens (Gast)]

ja soweit war ich auch, denn hardware arbeitet ja aber ich verstehe 
nicht waurm,da es ja in den Empfangsinterrupt springt und dort den code 
nicht erkennt

[Karl H. (kbuchegg)]

Jens schrieb:
> ja soweit war ich auch, denn hardware arbeitet ja aber ich verstehe
> nicht waurm,da es ja in den Empfangsinterrupt springt und dort den code
> nicht erkennt

Einen Moment, ich habe eine Eingebung.
Es ist alles sehr verschwommen. Aber die Geister der Softwarewelt zeigen 
mir eine symbolisierte 42! Vielleicht solltest du Zeile 42 mal genauer 
ansehen?

Mist, jetzt ist alles wieder weg. Irgendjemand hier im Forum hat eine 
schlechte Aura. Ich kann deinen Code nur noch schemenhaft erkennen ... 
nein, jetzt ist auch das letzte bischen Sicht nur noch verschwommen.

(Meine Glaskugel sollte mal dringend zur Reparatur. Kennt jemand einen 
günstigen Magierservice?)

[Jens (Gast)]

naja ich glaube das ist sehr unpassend und solltest du in einem anderen 
Thread verlagern passt nicht ganz zum Thema oder was meinst du?

Denn wie du sicherlich weißt gibt es keine dummen fragen nur dumme 
Antworten nun denk mal drüber nach

[Klaus (Gast)]

Naja, es gibt zwar keine dummen Fragen, aber unvollstaendige. Was was 
Karl Heinz dir auf humorvolle Art mitteilen wollte, ist dass dir keiner 
bei einem Fehler in deinem Code helfen kann, wenn du nicht deinen 
aktuellen Code herzeigst.

[Karl H. (kbuchegg)]

Jens schrieb:

> Denn wie du sicherlich weißt gibt es keine dummen fragen nur dumme
> Antworten nun denk mal drüber nach

Doch, es gibt dumme Fragen. Es ist nur mitlerweile verpönt, den 
Fragesteller darauf hinzuweisen. Eine dumme Frage ist zb. ein Anruf beim 
Arzt: "Doc, es tut weh. Was kann das sein?". Das IST eine dumme Frage, 
weil jedem, der seine 7 Zwetschken noch halbwegs beisammen hat, klar 
sein muss, dass man sie nicht beantworten kann.

Poste deinen Code. Und zwar so, wie er jetzt aussieht. Du gehst ja 
schliesslich auch selber zum Arzt und lässt ihn sich die Sache ansehen 
und berufst dich nicht auf deinen Bruder, der vor einer Woche beim Arzt 
war und so ähnlich aussieht wie du.

[Jens (Gast)]

sehr "humorvoll" ich würd das eher als unqualifiziert bezeichnen ...

Code ist gleich geblieben bis auf folgende zeilen

//Empfangsinterrupt
ISR(USART_RX_vect)                      // wird ausgelöst, wenn Daten empfangen wurden
{  
  u8_Datenstrom = UDR0;                  // empfangene Daten werden in "u8_Datenstrom" gespeichert    
  if( u8_Datenstrom == 0b00101011)            // ist die empfangene Bitfolge der Code?
  {
    u8_Code_empfangen = 1;
    //ROTE_LED_AN();                // wenn ja setze das Flag
    
  }
  else                              // wenn die empfangene Bitfolge nicht der code ist
  {//ROTE_LED_AN();
    if(u8_Code_empfangen == 1)              // Überprüfe ob die vorherige Folge der Code war --> es sind nun sinnvolle Daten
    {
      u8_Empfang = u8_Datenstrom;          // wenn ja schreibe die Bitfolge in "u8_Empfang"
      u8_Code_empfangen = 0;              // und setze das Flag zurück --> Übertragung abgeschlossen
    }
  }
}