Attiny 4313 UART Probleme

[Jonas E. (jonas_e43)]

Hallo,
ich bin gerade dabei meinen RFID Reader so umzubauen, dass er mit 
einem PC über UART kommunizieren kann.
Ich benutze den ISR(USART_RX_vect) Interrupt und möchte dann den String 
auslesen. Leider zeigt der Microcontroller dann nur Unsinn an oder hängt 
sich neuerdings auf...
Vielleicht hat ja von euch jemand eine Idee wo der Fehler liegt.
Würde mich über etwas Hilfe sehr freuen :)
Gruß Jonas

Hier der Code:
main.c

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

#include "em4100.h"
#include "lcd.h"
#include "rs232.h"

#ifndef F_CPU
#define F_CPU 14745600UL
#endif

void long_delay(uint16_t ms)
{
  ms = ms*(F_CPU / 1000000);
  for(; ms>0; ms--)
  _delay_ms(1);
}

char* tagToString(uint8_t* tag)
{
  const uint8_t SIZE = sizeof(char) * 5 * 2 + ( sizeof(char) );
  char* retVal = malloc(SIZE);
  uint8_t index = 0;
  
  for (uint8_t j=0; j<5; j++)
  {
    uint8_t nibble = (tag[j] >> 4) & 0x0f;
    if (nibble > 9)
    nibble += 'A'-10;
    else
    nibble += '0';
    retVal[index++] = nibble;
    
    nibble = tag[j] & 0x0f;
    if (nibble > 9)
    nibble += 'A'-10;
    else
    nibble += '0';
    retVal[index++] = nibble;
  }
  
  return retVal;
}
int main(void)
{
  
  lcd_init();
  UART_init();

  lcd_clear();
  DDRB |= ( 1 << DDB6) | ( 1 << DDB7 );

  TCCR0B = 1<<CS01 | 1<<CS00; //Timer/Counter0 prescaler 64
  MCUCR |= 1<<ISC10; //Any logical change on INT1 generates an interrupt request
  GIMSK |= 1<<INT1; //External interrupt request 1 enable (demod_out from RFID chip)

  sei();
  
  lcd_clear();
  
  uint8_t tag[5];
  while ( 1 )
  {
    lcd_clear();
    lcd_string("Ready.");
    
    if ( em4095_read_tag(tag))
      {
      char* tagString = tagToString(tag);
      lcd_clear();
      lcd_stringCenter("Tag ID:", 1);
      lcd_stringCenter(tagString, 2);
      UART_puts(tagString);
      
      free(tag);
      free(tagString);
      long_delay(3000);
    }
    
  }    

}

rs232.c

#include "rs232.h"

void UART_init(void)
{
  UBRRH = UBRR_VAL >> 8;
  UBRRL = UBRR_VAL & 0xFF;
  UCSRB = (1<<RXEN)|(1<<TXEN)|(1<<RXCIE); 
  UCSRC = (1<<UCSZ1)|(1<<UCSZ0);
}

uint8_t UART_peekchar(void)          // Auf Zeichen im UART Eingang prüfen
{
  return UCSRA & (1<<RXC);            // sofort zurückkehren und Zustand melden
}
  
uint8_t UART_getc(void)
{
  while (!(UCSRA & (1<<RXC)))   // warten bis Zeichen verfuegbar
  ;
  return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
}

char* UART_gets()
{
  int length = 1;
  char* line = malloc(sizeof(char) * length);
#if 0 == '\0'
  line[0] = -1;
#else
  line[0] = 0;
#endif
  
  while ( 1 )
  {
    line[length - 1] = UART_getc();
    if ( line[length - 1] == '\0' || line[length - 1] == '\n' )
      break;
    else
    {
      length++;
      
      char* newLine = realloc(line, sizeof(char) * length);
      if ( newLine != NULL )
        line = newLine;
      else
        break;
      
      line[length - 1] = 0;
    }
  }
  
  return line;
}  

void UART_putchar(char z)          // Zeichen in UART Ausgang geben
{
  while ( !(UCSRA & (1<<UDRE)) )        // Warte bis UART Ausgang frei
      ;
  UDR = z;
}
  
void UART_puts(char *s)            // Zeichenkette (String) in UART Ausgang geben
{
  while ( *s )
  {
    UART_putchar(*s);
    s++;
  }
  UART_putchar('\0');
}
  
  ISR(USART_RX_vect)
  {
    char* receivedString = UART_gets();
    lcd_clearLine(1);
    lcd_stringCenter(receivedString, 1);
    long_delay(2000);
  }

rs232.h

#ifndef RS232_H_
#define RS232_H_


#include <stdlib.h>
#include <avr/interrupt.h>

#include "lcd.h"

#ifndef F_CPU
#define F_CPU 14745600UL
#endif

#define BAUD 9600UL

#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


void UART_init(void);
 
// Auf Zeichen im UART Eingang prüfen
uint8_t UART_peekchar(void);
 
// Auf Zeichen im UART Eingang warten
uint8_t UART_getc(void);
 
// Zeichen in UART Ausgang geben
void UART_putchar(char z);
 
// Zeichenkette (String) in UART Ausgang geben
void UART_puts(char *s);

char* UART_gets( void );

#endif /* RS232_H_ */