Interrupt in Endlosschleife

[P. F. (pfuhsy)]

Hallo,

ich hab ein Problem mit meinen Interrupt. Er soll auslösen, sobald ein 
Zeichen über die UART empfangen wird. Das funktionert, doch wenn er 
einmal in der ISR-Routine ist, verlässt er diese nicht mehr und sendet 
den Text "Interrupt immer und immer weider. Ich versende lediglich ein 
einziges Zeichen. Ich hab schon einige Befehle durchprobiert, doch ich 
kriege das nicht hin. Was mache ich falsch ?


Gruss

#define F_CPU 3686400      //Taktfrquenz
#define BAUD 9600        //einstellte Baudrate
//-----------------------------
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <avr\io.h>
#include <avr\delay.h>
#include <avr/interrupt.h>
//----------------------------------------------------------------------
void Senden(char buffer[]);
void Debug(char buffer[]);
//----------------------------------------------------------------------

void initPorts() 
{
  DDRB   = 11111111;                     // PORTB = Ausgang
  DDRC   = 11111111;                     // PORTC = Ausgang
  DDRD   = 00000000;                     // PORTD = Eingang
  PORTD  = 00001000;              // PORTD = PULL-UP für den Taster
}

void initUART() 
{
  UBRRL  = (F_CPU / BAUD - 16) / 16;    //Baudberchnnung
  UCSRB  = 0x98;                   //Transmitter/Receiver/Receiver Interrupt Enable
  sei();                  // Interrupts zulassen
}

ISR(USART_RXC_vect) 
{
  Debug("Interrupt");
}

//----------------------------------------------------------------------
void putChar(char data) 
{
  while (!(UCSRA&32));        //warte bis UDR leer ist
  UDR = data;              //senden
}
//----------------------------------------------------------------------
char getChar()
{
  char data=0;
  while (!(UCSRA&128)); //warte bis RX-complete RXC UCSRA
  data=UDR; //empfangen

  return data;
}
//----------------------------------------------------------------------
void Senden(char buffer[]) 
{
  for (int i=0 ; buffer[i] !=0 ; i++)
    putChar(buffer[i]);
}

void Debug(char buffer[])
{
  Senden(buffer);
}

//----------------------------------------------------------------------
//----------------------------------------------------------------------
main()
{
  initPorts();
  initUART();

  int i=0;
  char text[5];
  do
  {
    /*
    char zeichen;
    zeichen = getChar();
    text[i] = getChar();
    i++;
    */

    //Debug ("main");
    //wenn 5 Zeichen (z.B. BTR1C) geschrieben sind, wird die variable zurückgesetzt
    if(i==5) 
    {
      i=0;

      if (text[3] == '1') 
      {
        PORTB |= (1 << PB0);
        Senden("BTR11A\n");

        waitMs(1000);
        PORTB &= ~(1 << PB0);
        Senden("BTR10A\n");
      }

      if (text[3] == '2') 
      {
        PORTB |= (1 << PB1);
        Senden("BTR21A\n");

        waitMs(1000);
        PORTB &= ~(1 << PB1);
        Senden("BTR20A\n");  
      }

      if (text[3] == '3') 
      {
        PORTB |= (1 << PB2);
        Senden("BTR31A\n");

        waitMs(1000);
        PORTB &= ~(1 << PB2);
        Senden("BTR30A\n");  
      }

    }
  }
  while (true);
}

[Michel (Gast)]

Wenn du den UART Transmit Interrupt freigibts, erzeugt das erste 
empfangene Zeichen einen explodierenden Rattenschwanz von 
Transmit-Interrupts, weil für jedes Zeichen deiner Debug-Ausgabe nach 
erfolgreichem Aussenden ein neuer Transmit Interrupt ausgelöst wird, der 
wieder den Text "Interrupt" aussenden möchte.
MfG

[P. F. (pfuhsy)]

Und wie kann ich den sagen, dass er die Routine nur einmal ausführen 
soll ?

[Karl H. (kbuchegg)]

Michel schrieb:
> Wenn du den UART Transmit Interrupt freigibts,

Hat er ja gar nicht

@Peter

Du musst das Zeichen in der ISR auch abholen.
Erst durch das Auslesen von UDR wird die Interruptanforderung wieder 
gelöscht.

[Karl H. (kbuchegg)]

Das hier

  UCSRB  = 0x98;

ist fast due dümmste SChreibweise, die du wählen kannst. Noch dümmer 
wäre nur noch eine Dezimalangabe

Warum nicht

  UCSRB = ( 1 << RXEN ) | ( 1 << TXEN ) | ( 1 << RXCIE );

da würde man auf einen Blick sehen, was du eigentlich eingestellt und 
freigegeben hast.

[P. F. (pfuhsy)]

Karl Heinz Buchegger schrieb:
> Warum nicht  UCSRB = ( 1 << RXEN ) | ( 1 << TXEN ) | ( 1 << RXCIE );
>
> da würde man auf einen Blick sehen, was du eigentlich eingestellt und
> freigegeben hast.

Danke für den Tipp, das werde ich verwenden.

Karl Heinz Buchegger schrieb:
> Du musst das Zeichen in der ISR auch abholen.
> Erst durch das Auslesen von UDR wird die Interruptanforderung wieder
> gelöscht.

Wie hole ich das empfangene Zeichen den ab ?

[Josef D. (jogedua)]

nicht direkt zum Problem,
aber das hier

  DDRB   = 11111111;                     // PORTB = Ausgang

soll ja wohl

  DDRB   = 0b11111111;                     // PORTB = Ausgang

heißen

[P. F. (pfuhsy)]

Wie hole ich das empfangende Zeichen denn jetzt ab, damit die 
Interrupt-Routine beendet wird ?

[Timmo H. (masterfx)]

Indem du in der ISR getChar() aufrufst bzw. einfach data=UDR;

[Josef D. (jogedua)]

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART

kurz:

  data=UDR; //empfangen

gehört in die ISR. Diese muss das Zeichen (z.B. in einem Ringpuffer) 
speichern.

char getChar()... muss dann jeweils ein Zeichen aus dem Ringpuffer 
zurückgeben statt selbst die UART auszulesen.

[Josef D. (jogedua)]

ich benutze stattdessen die
 UART library
aus
 http://homepage.hispeed.ch/peterfleury/avr-software.html

das Studium der Quelltexte ist auch sehr lehrreich.

[P. F. (pfuhsy)]

Sehr schön, danke für die Tipps. Hab es ausprobiert, funktioniert. 
Vielen dank für die Unterstützung.