Beim Interrupt Variable in die main übergeben

[Interruptor (Gast)]

Wir haben wieder ein kleines Problemchen. Wir machen ein Interrupt und
initialisieren in diesem Interrupt eine Variable. Wenn wir dann
allerdings wieder in unser main-Programm springen wird diese auf Eins
gesetzt und der vorher initialisierte Wert wird überschrieben. Hat einer
ne Idee was wir ändern könnten/müssen damits funktioniert?
Interrupt funktioniert, serielle Datenübertragung funktioniert, Display
funktioniert, volatile und sonstige Varianten alles schon ausprobiert,
alles läuft einwandfrei, nur die Variable will nich so wie wir wollen.
hier noch unser Quellcode:

#define F_CPU 12000000
#include <inttypes.h>
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include "lcd-routines.h"

#define BAUD 9600
#define MYUBRR F_CPU/16/BAUD-1
#define CTS (PINB & 1)

/*Funktionsprototypen*/
void USART_Transmit( unsigned char data );
void USART_Init( unsigned int ubrr);
void Schreibe_in_Binaer(unsigned char test);

/*globale Variablen*/
unsigned char receive_old=0;
volatile unsigned char receive=1;

/*Interrupt*/
ISR(USART_RXC_vect)
{
  receive = UDR;
  lcd_setcursor(0,1);
  Schreibe_in_Binaer(receive);
}


/*Hauptprogramm*/
int main(void)
{
  DDRD = 0xF0;
  lcd_init();
    USART_Init( MYUBRR);
  sei();

  while(1)
  {
    /*Lauflicht*/
    PORTD = 0x80;
    _delay_ms(400);
    PORTD = 0x40;
    _delay_ms(200);
    PORTD = 0x20;
    _delay_ms(200);
    PORTD = 0x10;
    _delay_ms(400);
    PORTD = 0x20;
    _delay_ms(200);
    PORTD = 0x40;
    _delay_ms(200);
    USART_Transmit(0x53);
    //Befehl wird empfangen

    lcd_setcursor(0,2);
    Schreibe_in_Binaer(receive);

  }

  return 0;
}


void USART_Init( unsigned int ubrr)
{
/* Set baud rate */
UBRRH = (unsigned char)(ubrr>>8);
UBRRL = (unsigned char)ubrr;
/* Enable receiver and transmitter */
UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE)|(1<<TXCIE);
/* Set frame format: 8data, 1stop bit */
UCSRC = (1<<URSEL)|(3<<UCSZ0);//(1<<USBS)|
}

void USART_Transmit( unsigned char data )
{
/* Wait for empty transmit buffer */
while ( (!( UCSRA & (1<<UDRE)))|| CTS )
;
/* Put data into buffer, sends the data */
UDR = data;
}

//Ausgabe eines Bytes in Binärem Code
void Schreibe_in_Binaer(unsigned char test)
{
  int i;
  unsigned char schreib[9];
  for(i=0; i<8; i++)
  {
    if (test & 1<<(7-i))
    {
      schreib[i] = '1';
    }
    else
    {
      schreib[i] = '0';
    }
  }
  schreib[8]=0;
  lcd_string( schreib);
}

[H.Joachim S. (crazyhorse)]

Vielleicht mal kurz anmerken, um welche Variable es geht??

[Interruptor (Gast)]

receive = UDR; // Im Interrupt wird sie beschrieben
Schreibe_in_Binaer(receive); // In der main tritt das oben beschrieben 
Problem auf

[Karl H. (kbuchegg)]

Sicher, dass ihr nur 1 einziges Zeichen von der Gegenstelle empfängt?

Vom Zeitpunkt an dem der µC die 0x53 wegschickt bis zum Zeitpunkt an dem 
das Zeichen dann irgendwann reinkommt, vergeht ja auch Zeit. D.h. es ist 
ziemlich unwahrscheinlich, dass in 1 und demselben Durchlauf durch die 
while Schleife, nach dem

    USART_Transmit(0x53);
    //Befehl wird empfangen

gleich danach an dieser Stelle

    lcd_setcursor(0,2);
    Schreibe_in_Binaer(receive);

ein empfangenes Zeichen sofort verfügbar ist. Da wird Zeit dazwischen 
vergehen. Nur dauert eure while Schleife durch die vielen Delays schon 
mal mindestens ein ca  einhalb Sekunden. Laufen in diesen 1.5 Sekunden 
mehrere Zeichen auf der UART ein, dann kriegt sie davon nichts mit, weil 
sie von den Delays ausgebremst wird.

[Rufus Τ. F. (rufus)]

Interruptor schrieb:
> Schreibe_in_Binaer(receive);

Warum wird das sowohl in main als auch in der ISR aufgerufen?

[spontan (Gast)]

Delays sind meist Schwachsinn, sie machen fast immer Ärger.
Hier mit Sicherheit.

[Interruptor (Gast)]

Durch das Aufrufen in der main un in dem ISR wollen wir ja die Variablen 
vergleichen (auf dem Display)

[Interruptor (Gast)]

Wir haben jetzt auch mal mit dem Oszilloskop nachgemessen und es kommt 
wirklich nur ein einziges Zeichen an.

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

LCD-Ausgabe in einer ISR ist auch nicht der Weisheit letzter Schluss - 
insbesondere nicht, wenn auch im Hauptprogramm eine erfolgt und sich das 
munter mischen kann. Also beispielsweise wenn mittendrin im LCD-Code der 
Interrupt sich einmischt.

[Pako (Gast)]

Interruptor schrieb:
> while(1)
>   {
>     ...
>     lcd_setcursor(0,2);
>     Schreibe_in_Binaer(receive);
>   }

Funktionen, die sowohl aus einer ISR als auch aus main() aufgerufen 
werden, müssen entweder
- reentrant programmiert sein (was Deine nicht sind), oder
- während des Aufrufes durch main() muß der Interrupt gesperrt sein (was 
Deiner nicht ist).

In Deinem Fall kann main() gerade in lcd_setcursor() sein, und dann 
kommt der Interrupt und geht nochmal in lcd_setcursor(). Was passiert 
dann? Datenmurks im Quadrat!

Du kommst mit sowas schnell in Teufels Küche, daher vermeidet man so 
einen Aufruf-Mix nach Möglichkeit.

[Karl H. (kbuchegg)]

Siehe
Beitrag "Beim Interrupt Variable übergeben in die Main"