UART Receive Interrupt funktioniern nicht!

[Benedikt K. (benek)]

Das Programm soll das Empfangene Byte immer wieder wiederholen. Jedoch 
Empfange ich nach dem ich ein Byte zum µC geschickt habe, nichts mehr. 
Wo liegt mein Fehler?

#define F_CPU 16000000

#define baud_value 103 //baudrate = 9600

#define Zeilenumbruch "\r\n"

#include <avr/io.h>
#include <math.h>
#include <util/delay.h>
#include <avr/interrupt.h>

uint8_t UARTReceivedByte;

void uartInit(void){
  UCSR0C |= (1<<UPM01); //Even Parity
  UCSR0C |= (1<<UCSZ01) | (1<<UCSZ00); // 8 Bit, 1 Stopbit, Asynchronos
  UBRR0H = (unsigned char) (103 >> 8); //baudrate = 9600
  UBRR0L = (unsigned char) 103;
  UCSR0B |= (1<<RXCIE0); //Receive Interrupt
  UCSR0B |= (1<<RXEN0) | (1<<TXEN0); //TX und RX aktiviert
  sei();
}

void uartTransmitByte (uint8_t data)
{
  while (! (UCSR0A & (1 << UDRE0)) )
  {
    
  }
  UDR0 = data;
}

void uartTransmitString (char *s)
{
  while (*s){   /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
  uartTransmitByte(*s);
  s++;
  }
}
void adcInit(void){
  ADMUX |= (1<<REFS0); //sets Reference to AVCC
  ADMUX |= (1<<ADLAR); //sets ADC Result to ADCH
  ADCSRA |= (1<<ADPS2) | (1<<ADPS1) | (1<<ADPS0); //Prescaler = 128 -> ADC Clock = 125 kHz
  ADCSRA |= (1<<ADEN);
  ADCSRA |= (1<<ADSC); //stabilise
}

uint8_t adcRead(void){
  int ADCResult;
  ADCSRA |= (1<<ADSC); //start Conversion
  while (ADCSRA & (1<<ADSC)) //wait until conversion has ended
  {
    ;
  }
  ADCResult = ADCH; //ADC Result
  return ADCResult;
}

ISR(USART_RX_vect){
  UARTReceivedByte = UDR0;
}
  
int main(void)
{
  uartInit();
  
    while(1)
    {
    uartTransmitByte(UARTReceivedByte);
    _delay_ms(1000);
    }
}

mfg

[al_guesto (Gast)]

Weil dein UDR "leer" ist nachdem du es ausgelesen hast. Wenn du stetig 
etwas sendest (vom PC) kommt auch immer was zurück, oder wirklich nur 
das erste Byte was du sendest?

[Dietrich L. (dietrichl)]

Benedikt K. schrieb:
> uint8_t UARTReceivedByte;

Auch wenn ich mit dem beschriebenen Fehler noch keinen direkten 
Zusammenhang sehe, hier müsste es heißen:

volatile uint8_t UARTReceivedByte;

Gruß Dietrich

[Karl H. (kbuchegg)]

Welcher µC?

Je nachdem heißt der Interrupt Vektor
ISR(USART_RX_vect){

ein wenig anders. Auf manchen AVR heißt der auch USART_RXC_vect