bug in Atmega32?

[fragender (Gast)]

Ich habe hier eine kleine FW geschrieben (Anhang) die über die 
UART-Schnittstelle Zeichen einliest und wieder zurücksendet (die FW wird 
später noch erweitert).
Folgendes Problem ist aufgetreten:
Wenn ich in der Main _delay_us(1); wegkommentiere werden keine Zeichen 
gesendet. Mir ist das unerklärlich warum das sein könnte.

Folgende Daten:
Atmega32, 8MHz Takt

Hat da jemand eine Idee??

[Mampf F. (mampf)]

fragender schrieb:
> Hat da jemand eine Idee??

Die da sollten auf jedenfall volatile-deklariert sein, sonst kann es 
Probleme mit der Optimierung geben:

uint8_t uart_complete=0;
char data_string[200];

Sie werden im Interrrupt verändert und das kann in der Main-Loop 
Probleme machen.

[Karl M. (Gast)]

Nee nicht ganz so.

Die Variable sind local und werden nach jedem Durchlauf vernichtet.

unsigned char next_byte;
uint8_t uart_str_count = 0;

Richtig ist das Schlüsselwort static.

uart_str_count++;

Außerhalb der der IF-Abfrage ist auch falsch!

if (uart_str_count<=200){
// ....
} else {
// ....
}
uart_str_count++;

[A. (Gast)]

Da gibts einiges zu verbessern. Schau mal folgende schnell gebastele 
Variante von mir an:

#define F_CPU 8000000UL
#define UART_BAUD_RATE 9600L
#define UART_BAUD_CALC(UART_BAUD_RATE,F_CPU) ( (F_CPU)/(UART_BAUD_RATE*16L)-1 )


#include <stdio.h>

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

volatile _Bool bReady = false;
volatile char aucData[200];
volatile uint8_t ucPos = 0;

int uart_putc(unsigned char c){
  while (!(UCSRA & (1<<UDRE)));
  
  UDR = c;
  return 0;
}

void uart_puts (const char *s)
{
  while (*s) {
    uart_putc(*s++);
  }
}

int main(void)
{
  lcd_ini();
  
  DDRB=0xFF;
  
  UCSRB|= (1<<RXEN) | (1<<TXEN) | (1<<RXCIE);
  UCSRC|= (1<<UCSZ0) | (1<<UCSZ1);
  
  UBRRH= (uint8_t) (UART_BAUD_CALC(UART_BAUD_RATE,F_CPU)>>8);
  UBRRL= (uint8_t) UART_BAUD_CALC(UART_BAUD_RATE,F_CPU);
  
  sei();
  
    while(1){
    if (bReady){          //Es soll gesendet werden?          
      uart_puts(aucData);    //String senden
      ucPos = 0;        //Bufferposition auf 0 setzen
      bReady = false;      //Empfang wieder freigeben
    }
    }
}



ISR (USART_RXC_vect)
{  
  char ucVal;
  
  ucVal=UDR;
  
  if(bReady)            //Sendet gerade?
    return;            //Empfangenes Zeichen ignorieren
  
  if(ucPos == 199)        //Letzte freie Position?
    ucVal = '\0';        //Zeichen zu Stringende konvertieren
    
  aucData[ucPos++] = ucVal;    //Zeichen abspeichern
  
  if(ucVal == '\0'){        //Stringende erhalten?
    bReady = true;        //String senden!
  }
}