ATMega Programmierung in c - Interrupt

[Thomas H. (datatom)]

Hallo zusammen,

ich habe aus dem Atmel Beispiel folgenden Interrupt erstellt:

ISR(USART0_RX_vect)
{

  unsigned char data;
  unsigned char tmphead;

  /* Read the received data */
  data = UDR0;
  /* Calculate buffer index */
  tmphead = (USART0_RxHead + 1) & USART_RX_BUFFER_MASK;
  /* Store new index */
  USART0_RxHead = tmphead;

  if (tmphead == USART0_RxTail) {
    /* ERROR! Receive buffer overflow */
  }
  /* Store received data in buffer */
  USART0_RxBuf[tmphead] = data;
  //USART0_RxBuf_global[tmphead] = data;
}

Der Interrupt wird mehrmals durchlaufen, solange Daten empfangen werden. 
Kann ich das Ende des Interruptes feststellen, denn da wollte ich ein 
Flag setzen?

Vielen Dank.

Gruß

datatom

[Joachim B. (jar)]

vor der letzten Klammer ist doch das Ende und dort kann dein Flag oder 
Counter rein, aber wozu?

Ich mache das selten am Anfang und Ende einen Port wackeln lassen um mit 
dem Oscar Zeiten zu messen.

[Felix U. (ubfx)]

das "Ende des Interrupts" ist am Ende des ISR() Kontextes, ich vermute 
also du meinst etwas anderes. Welchen Zustand möchtest du genau 
erkennen?

[Thomas H. (datatom)]

Wenn der ATMega Daten empfängt die zusammen gehören, Beispiel 
"AT+CPIN=0000", dann wird jeder Ascii-Wert der Buchstaben und Zahlen in 
das Array USART0_RxBuf geschrieben:

USART0_RxBuf[tmphead] = data;

bis das Ende erreicht ist. Da ich nicht weiß welcher Wert als letztes 
kommt, muss ich also wissen, wann das Ende des Interrupt erreicht ist, 
um das Flag zu setzen.

Wenn ich das AT-Kommando absetze und auf die Antwort warte, läuft das 
Programm solange weiter, das soll es aber nicht. Das Programm soll das 
At-Kommando absetzen und auf Antwort warten und dann erst weitermachen.

[W.A. (Gast)]

Thomas H. schrieb:
> Da ich nicht weiß welcher Wert als letztes
> kommt, muss ich also wissen, wann das Ende des Interrupt erreicht ist,
> um das Flag zu setzen.

Der Interrupt dient zum Abholen der empfangenen Zeichen vom USART. Die 
Interpretation des Datenstroms ist ein ganz anderes Thema und hat mit 
dem Interrupt nichts zu tun. Gewöhnlich schiebt die ISR die Zeichen in 
einen Ringpuffer und über die Position von Schreib- und Lesezeiger wird 
der Puffer koordiniert.

[Thomas H. (datatom)]

Also gibt es keine Möglichkeit das Ende des Interrupts zu ermitteln?

[Peter II (Gast)]

Thomas H. schrieb:
> Also gibt es keine Möglichkeit das Ende des Interrupts zu ermitteln?

nein, der Interrupt wird für jedes Zeichen aufgerufen. Es gibt kein 
"ende".

> Da ich nicht weiß welcher Wert als letztes
> kommt, muss ich also wissen, wann das Ende des Interrupt erreicht ist,
> um das Flag zu setzen.
doch das weißt du. Am ende eines AT-Befehles kommt eine '\n'. Dann ist 
der Befehl abgeschlossen.

[Peter D. (peda)]

Thomas H. schrieb:
> Also gibt es keine Möglichkeit das Ende des Interrupts zu ermitteln?

Wurde doch schon gesagt, die letzte Zeile der ISR.

Aber Du meinst was völlig anderes, nämlich das Ende eines Datenpakets. 
Und das kann man nur feststellen, wenn man das Protokoll kennt. Du mußt 
also zuerst mal ein Protokoll festlegen.

[M. K. (sylaina)]

Thomas H. schrieb:
> Wenn der ATMega Daten empfängt die zusammen gehören, Beispiel
> "AT+CPIN=0000", dann wird jeder Ascii-Wert der Buchstaben und Zahlen in
> das Array USART0_RxBuf geschrieben:
>
> USART0_RxBuf[tmphead] = data;
>
> bis das Ende erreicht ist. Da ich nicht weiß welcher Wert als letztes
> kommt, muss ich also wissen, wann das Ende des Interrupt erreicht ist,
> um das Flag zu setzen.

Du suchst also gar nicht das Ende des Interrupts sondern willst wissen, 
wann dein Datenempfang vollständig ist. Dazu musst du dir ein Protokoll 
überlegen, das kannst du nicht in der ISR abfangen. Typisch beim 
UART/RS232 ist ein Carrige Return + Linefeed ('\r\n')die das Ende eines 
Datensatzes markieren.
In der ISR kannst du bestenfalls ein Flag setzen, dass aussagt: "Hey, 
ich hab die Zeichenkombination für das Ende eines Datensatzes 
empfangen."

[Florian (Gast)]

Hallo Thomas,

Deine AT-Antwort wird am Ende des ASCII-Textes auch Steuerzeichen 
enthalten, die das Ende der Nachricht kennzeichnen. Dies ist meist 0x0A 
oder 0x0D, schau mal in eine ASCII-Tabelle im Internet. Auf diese 
Zeichen, kannst Du in Deiner ISR, die eigehenden Zeichen hin prüfen und 
dann mit einem Flag die Nachricht in der main() verarbeiten. Mach dies 
nie in der isr, da dies zu Zeitaufwändig ist. Die isr immer so kurz wie 
möglich halten.

Ich mache das immer so:

ACHTUNG: Der Code ist nur fürs Verständnis runtergeschrieben. Er ist 
nicht compiliert und kann Fehler enthalten!

Gruß
Florian

#define RX_BUFFER_SIZE 64 
char RxBuffer[RX_BUFFER_SIZE];    // In dieses Array (Buffer) werden die empfangenen Zeichen in der isr gespeichert
uchar RxIndex = 0;      // Laufvariable für den Buffer
uchar RxCompleteFlag = 0;    // Flag, um ein empfangenes Kommando in der main zu signalisieren


// ggf. RxBuffer[] initialisieren

main()
{
  if(RxCompleteFlag)
  {
    // verarbeite hier Dein Kommando aus dem Buffer
    if(strcmp(RxBuffer, "AT+CPIN=0000") == 0)
    {
      // Do something
    }

    // Am Ende! wieder zurücksetzen
    RxCompleteFlag = 0;
// Wenn Du magst, kannst Du hier das Buffer-Array auch noch löschen  
  
  }
}


USART_isr()
{
unsigned char data;

  data = UDR0;

  // Nur wenn Daten in den Buffer geschrieben werden können
  if(!RxCompleteFlag)
  {
    if((data == 0x0D) || (data == 0x0A) || (RxIndex >= RX_BUFFER_SIZE))
    {
      // Zeilenende erreicht, oder Bufferoverflow vermeiden
      RxCompleteFlag = 1; 
      // Laufvariable wieder auf 0 setzen
      RxIndex = 0;      
    }
    else
    {
      // Solange Zeichen ankommen, in den Buffer schreiben
      RxBuffer[RxIndex] = data;
      // Laufvariable inkrementieren
      RxIndex++;
    }
  }  
}

[Joachim B. (jar)]

ich würde ja noch

      // Solange Zeichen ankommen, in den Buffer schreiben
      RxBuffer[RxIndex] = data;
      // Laufvariable inkrementieren
      RxIndex++;

      // Solange Zeichen ankommen, in den Buffer schreiben
      if(isprint(data))
      {
            if( data != '/r' && && data != '/n' )
            {
                  RxBuffer[RxIndex] = data;
                  // Laufvariable inkrementieren
                  RxIndex++;
                  var_str_complete = 0;
            }
            else
            {
                  RxBuffer[RxIndex] = '\0';
                  var_str_complete = 1;
            }
      }

oder ähnlich einfügen