UART Empfangen/Senden mit Atmega1284

[A. R. (and)]

Guten Tag,

ich bin noch relativ neu in der µC Programmierung.
Nach mehreren Tagen Google und vielen Beispielen habe ich immer noch 
nichts Brauchbares gefunden, bzw. auch noch nicht alles verstanden: 
Warum, Wieso, Weshalb.....
Habe bereits ein Beispiel versucht nach zu programmieren, jedoch nur mit 
einer Menge Fehlern. "AVR-GCC-Tutorial/Der UART"


Ich möchte gerne folgendes Umsetzten:
Regelmäßig den UART abfragen ob Werte ankommen (z.B. Zeichenkette vom 
Typ char „OK“).
Wenn ein entsprechender Wert angekommen ist, möchte ich mehrere 
Variablen des Typ „uint16_t“ per UART Senden.

Beim Senden ist mein bisheriges Programm definnitiv ganz falsch.


Meine Hardware:
Atmega 1284P;   Quarz mit 14,7456MHZ;   UART: TXD an PD1 / RXD an PD0


Antworten bitte Anfängerfreundlich.


Mein aktuelleer Quelltext:

#define F_CPU 14745600UL     // CPU Taktfrequenz
#include <util/delay.h>       //
#include <avr/io.h>               //


#define BAUD 9600UL      // Baudrate

//Berechnung der Baudrate
#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.


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



// ------------------------------------------------------------
// UART initalisieren

  void uart_init(void) {
      UBRRH = UBRR_VAL >> 8;
      UBRRL = UBRR_VAL & 0xFF;
 
      UCSRB |= (1<<TXEN);  // UART TX einschalten
     UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
  }


// ------------------------------------------------------------
// UART Empfangen

  uint8_t uart_getc(void) {
    while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar
        
    return UDR;                   // Zeichen aus UDR an Aufrufer zurueckgeben
  }
 

  void uart_gets( char* Buffer, uint8_t MaxLen ) {
      uint8_t NextChar;
      uint8_t StringLen = 0;
 
      NextChar = uart_getc();         // Warte auf und empfange das nächste Zeichen
 
                                    // Sammle solange Zeichen, bis:
                                    // * entweder das String Ende Zeichen kam
                                    // * oder das aufnehmende Array voll ist
    while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
      *Buffer++ = NextChar;
      StringLen++;
      NextChar = uart_getc();
    }  
 
                                    // Noch ein '\0' anhängen um einen Standard
                                    // C-String daraus zu machen
    *Buffer = '\0';
  }


// ------------------------------------------------------------
// UART Senden

  int uart_putc(unsigned char c) {
      while (!(UCSRA & (1<<UDRE)))  /* warten bis Senden moeglich */
      {
      }                             
 
    UDR = c;                      /* sende Zeichen */
    return 0;
  }
 
 
/* puts ist unabhaengig vom Controllertyp */
  void uart_puts (char *s) {
      while (*s) {         /* so lange *s != '\0' also ungleich dem "String-Endezeichen(Terminator)" */
        uart_putc(*s);
        s++;
      }
  }



// ------------------------------------------------------------
// ------------------------------------------------------------

int main (void) {        
 
    DDRC  = 0xFF;                 // Digitale Ausgänge
   
  uint16_t x1, x2, x3, x4;     // Variable
  
     
   while(1) 
   {      
   

//-----------UART Werte senden-----------// !!!ÜBERTRAGEN von x1-x4!!!
  
  char s[7];    
     int16_t i = -12345;
 
     uart_init();
 
     itoa( i, s, 10 ); // 10 fuer radix -> Dezimalsystem
     uart_puts( s );
 
     // da itoa einen Zeiger auf den Beginn von s zurueckgibt verkuerzt auch:
     uart_puts( itoa( i, s, 10 ) );

//-------------------------------------//

   }                         
 

   return 0;                
}

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Andi R. schrieb:
> Beim Senden ist mein bisheriges Programm definnitiv ganz falsch.
Dann würde ich da mal anfangen.
Wie stellst du fest, dass dein Programm falsch ist?
Was passiert, wenn du mal
uart_puts("Hallo!");
schreibst?
Stimmt deine Taktfrequenz (die CKDIV8 Fuse)?

[A. R. (and)]

Ich wollte jetzt erst mal veruschen das Tutorial nach zu programmieren 
und dann zu ändern wenn das Falsch wäre.

Wenn ich einen anderen Wert als OK bekomme, soll erstmal nicht 
passieren.
Die Struktur werde ich dann mit eienr IF Bedinung auswerten und dann 
darin die entsprechenden Werte senden.

Die Fuses habe ich laut www.engbedded.com/fusecalc eingestellt:
Low: 0x7F   / High:0x99   / Extended: 0xFF

[Karl H. (kbuchegg)]

Andi R. schrieb:

> Antworten bitte Anfängerfreundlich.

ok.
anfängerfreundlich.

Kauf dir ein C Buch und arbeite das zunächst mal in den ersten Kapiteln 
durch.

Dort erfährst du dann zum Beispiel, dass in C ausführbare Anweisungen 
immer innerhalb von Funktionen stecken. Das heisst, dass hier


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

ist so nicht möglich, weil diese Anweisungen nicht in einer Funktion 
stecken.

Ganz abgesehen davon, dass sie hier auch keinen irgendwie gearteten Sinn 
ergeben, denn die Aktivierung der UART findet sowieso in der Funktion 
uart_init statt.

void uart_init(void) {
      UBRRH = UBRR_VAL >> 8;
      UBRRL = UBRR_VAL & 0xFF;
 

// ***** hier steckt die Aktivierung des Transmitters
      UCSRB |= (1<<TXEN);  // UART TX einschalten
// *****
     UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);  // Asynchron 8N1 
  }

Wie gesagt: kauf dir ein C-Buch.
Es hat keinen Sinn zu glauben, man könne seine erste Programmiersprache 
dadurch lernen, dass man sich im Web Dinge zusammenkopiert. Das geht mit 
Sicherheit schief, da programmieren mehr ist, als nur einfach irgendwas 
hinzuschreiben und der Compiler wird sich dann schon seinen Reim darauf 
machen.