Atmega8 Uart Interrup

[Jürgen (Gast)]

Hallo Leute,

hab an meinem Atmega8 einen Max232 und habe jetzt eine wenig Code 
zusammenschustert der durch einen Interrupt einen String einließt und 
diesen dann ausgiebt. Funktioniert leider noch nicht so ganz.

#include <avr/io.h>
#include <stdlib.h>
#include <avr/interrupt.h>
#define F_CPU 4000000
#include <util/delay.h>
#define BAUD 9600
#define UBRR_VAL F_CPU/16/BAUD-1

volatile uint16_t wert;


#define UART_MAXSTRLEN 10
 
volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_string[UART_MAXSTRLEN + 1] = "";

char buffer[10];            // oder ein anderer passender Wert


void delay_ms(int delay) 
{
  int i;
  for (i=0;i<=delay;i++) 
  {
    _delay_ms(1);
  }
}

void init_uart(unsigned int ubrr)
{
  UBRRH = (unsigned char)(ubrr>>8);
  UBRRL = (unsigned char)(ubrr);
  UCSRB |= (1<<RXEN);
  UCSRB |= (1<<TXEN);
  UCSRB |= (1<<RXCIE);
  UCSRC = (1<<URSEL)|(1<<USBS)|(3<<UCSZ0);
}

void send_char(unsigned char data) 
{
        while (!(UCSRA & (1<<UDRE)));
        UDR = data;
}

void send_string(char *data) 
{
  while (*data)
  {
      send_char(*data);
      data++;
  }
}



ISR(USART_RXC_vect)
{
  unsigned char nextChar;
 
  // Daten aus dem Puffer lesen
  nextChar = UDR;
  if( uart_str_complete == 0 ) {  // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
 
    // Daten werden erst in string geschrieben, wenn nicht String-Ende/max Zeichenlänge erreicht ist/string gerade verarbeitet wird
    if( nextChar != '\n' &&
        nextChar != '\r' &&
        uart_str_count < UART_MAXSTRLEN - 1 ) {
      uart_string[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else {
      uart_string[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
    }
  }
}

int main(void) {
  init_uart(UBRR_VAL);

    while(1)
  {
   _delay_ms(1000);  
        wert = uart_string; 
  send_string("wert: ");
  send_string(utoa(wert, buffer, 10));
  }
}

Findet jemand hier den Wurm?

Vielen Dank und an alle Frohe Feiertage!

[Huch (Gast)]

Bitte klar und vollständige Information darüber, was der Code genau tun 
soll, wie Du feststellst, das er das nicht tut und über Deine Ergebnisse 
der der Ursachenforschung.

Wir sind hier nicht die Weihnachtsmänner, denen man ein Stück Code mit 
der Bemerkung "geht nicht" hinwirft und die dann den Rest für Dich 
machen.

An Deiner Rechtschreibung, könntest Du auch noch arbeiten.

[Klaus W. (mfgkw)]

Immerhin kennt er [c], sonst hast du vollkommen recht.

[Eddy C. (chrisi)]

Der Interrupt wird nicht global eingeschaltet?

[Jürgen (Gast)]

Entschuldigt.

Der Code soll folgendes machen: einen String empfangen welcher vom PC 
aus Via Terminal geschickt wird und diesen dann via

{c]  send_string(utoa(wert, buffer, 10));[/c]

ausgeben. Momentan lautet meine Ausgabe jedoch durchgehen "103".

Vielen Dank.

[Huch (Gast)]

Ich gebs auf. Da ist Hopfen und Malz verloren.

[Eddy C. (chrisi)]

Huch, wenn Du nix beizutragen hast, bau halt nen Schneemann, das ist ja 
nicht auszuhalten.

Jürgen:

Abgesehen vom Interrupt, der nicht ein ist, sollte Dir die Zeile hier:

wert = uart_string;

etwas sportlich vorkommen. Da würde man lieber sowas wie

wert = atoi(uart_string);

sehen.

[Huch (Gast)]

@ Eddy Current

Ich schreibe was ich für richtig halte. Wenn Du das nicht aushälst, ist 
das allein Dein Problem.

[Jürgen (Gast)]

Danke Eddy!

Nun würde ich noch gern wissen ob jemand einen Tipp hat wie ich die 
Interruptroutine so verändern kann das der Ausgabestring "uart_string" 
immer wieder überschriebenwird und das schreiben in den String nicht 
aufhhört wenn dieser voll ist.

Vielen Dank,