UART Datenaustausch Verständnisfragen

[Dido (Gast)]

Hallo liebe Gemeinde,

ich bin relative neu was die Programmierung vom Mikrocontrollern angeht 
und brauche daher noch immer wieder Denkanstöße, um auf die Lösung zu 
kommen.
Momentan möchte ich Daten an den Controller schicken, welcher diese dann 
an den PC zurückgibt bzw. auf dem PORTA auslegt.
Das Programm verstehe ich soweit, dass Strings gesammelt und in einem 
Puffer gesammelt werden, bis eine max. Anzahl von Strings erreicht bzw. 
das Terminatorzeichen eingegeben wird.
Was mir aber noch unklar ist:
1. Welche Variable beinhaltet die konkreten, über die Tastatur 
eingegebenen Werte? Ich vermute es ist nextChar?!

2. Wie kann ich mir diesen UDR-Puffer vorstellen? Werden dort sämtliche 
Zeichen gesammelt oder nur einzelne Strings gespeichert?
Ist es in 2 Register unterteilt (also TX und Receive)? Wenn ja, wie 
unterscheidet man beim Zugriff die beiden Register?

3. Wie modifiziere ich das Programm, dass es die gwünschten Funktionen 
erfüllt? Ich habe ja ein schlechtes Gewissen, dass ich keinen richtigen 
Code anbieten kann, aber ich tappe ziemlich im Dunkeln und die 
bisherigen Versuche waren auch nur Müll...

Ich bedanke mich schonmal im Voraus!

#include <avr/io.h>
#include <avr/interrupt.h>
#define F_CPU 8000000UL
#define BAUD 9600UL

// Berechnungen
#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


#define UART_MAXSTRLEN 8

volatile uint8_t uart_str_complete = 0;     // 1 .. String komplett empfangen
volatile uint8_t uart_str_count = 0;
volatile char uart_stringlength[UART_MAXSTRLEN + 1] = "";
unsigned char nextChar;

void Init (void)
{
  UCSR0B|= (1<<TXEN0) |(1<<RXEN0) | (1<<RXCIE0) | (TXCIE0) | (UDRIE0); //Enable Transmitter/Receiver and concerning Interrputs
  UCSR0B|= (1<<UCSZ00) | (UCSZ01);
}

int uart_putc(unsigned char c)
{
  while (!(UCSR0A & (1<<UDRE0))) 
  {
  }
  
  UDR0 = c;                    
  return 0;
}


void uart_puts (char *s)
{
  while (*s != '\0')
  {  
    uart_putc(*s);
    s++;
  }
}

int main(void)
{   DDRC= 0xFF;
  Init();
  
  sei();
  
    while(1)
    {
        
    }
}

ISR(USART0_RX_vect)
 {
  
  // Daten aus dem Puffer lesen
  nextChar = UDR0;

  if( uart_str_complete == 0 ) // wenn uart_string gerade in Verwendung, neues Zeichen verwerfen
  {  
    
    // Daten werden erst in uart_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 )
    {
      uart_stringlength[uart_str_count] = nextChar;
      uart_str_count++;
    }
    else
    {
      uart_stringlength[uart_str_count] = '\0';
      uart_str_count = 0;
      uart_str_complete = 1;
      uart_putc(nextChar);
      
        
    }

  }
  }

P.S. Das Senden von Daten an den PC klappte bereits gut mit meinem 
ATmega8.

[spess53 (Gast)]

Hi

>UCSR0B|= (1<<TXEN0) |(1<<RXEN0) | (1<<RXCIE0) | (TXCIE0) | (UDRIE0)
                                                 ^^^^^^^^   ^^^^^^^^

Das solltest du dringend ändern. Allerdings fehlen die zugehörigen ISRs.

MfG Spess

[Dido (Gast)]

spess53 schrieb :
> Hi
>
>>UCSR0B|= (1<<TXEN0) |(1<<RXEN0) | (1<<RXCIE0) | (TXCIE0) | (UDRIE0)
>                                                  ^^^^^^^^   ^^^^^^^^
>
> Das solltest du dringend ändern. Allerdings fehlen die zugehörigen ISRs.
>
Upss Flüchtigkeitsfehler. Jap die ISRs fehlen, hab ich aber erstmal 
aktiviert, für den Fall das ich sie doch brauche :)

[Karl H. (kbuchegg)]

Dido schrieb:

> Das Programm verstehe ich soweit, dass Strings gesammelt

genauer gesagt: 1 String (in Worten: einer)

> und in einem
> Puffer gesammelt werden, bis eine max. Anzahl von Strings erreicht bzw.
> das Terminatorzeichen eingegeben wird.
> Was mir aber noch unklar ist:


Was dir unklar ist, das ist der Unterschied zwischen einem einzelnen 
Zeichen und einem String. Ein String ist kein Zeichen. Ein String 
besteht aus mehreren Zeichen.

Ein Zeichen, das ist zb 'A' oder 'B' oder 'Z' oder auch '0' oder '/'. 
Drückst du im Terminal auf eine Taste, dann schickt das Terminal ein 
einzelnes Zeichen auf die Reise.

Erst die Zusammensetzung mehrerer Zeichen nennt man dann einen String.
"Hello World" ist ein String. Oder auch "01234" ist ein String. Oder 
"08/15" ist ein String. Bestehend aus mehreren Zeichen.

> 1. Welche Variable beinhaltet die konkreten, über die Tastatur
> eingegebenen Werte? Ich vermute es ist nextChar?!

Nein.
Es ist ein Stufenprozess.
Jedes Zeichwn wird einzeln übertragen. Zunächst landet das Zeichen in 
nextChar. Von dort wird es dann an den String in uart_stringlength 
angehängt. (Wer hat sich denn den Variablennamen ausgedacht? Ich wars 
nicht, auch wenn ich den Code als meinen wiedererkenne)

> 2. Wie kann ich mir diesen UDR-Puffer vorstellen? Werden dort sämtliche
> Zeichen gesammelt oder nur einzelne Strings gespeichert?

Dort wird 1 Zeichen gespeichert. Nämlich das nächste Zeichen, welches 
über die UART reinkommt.

> Ist es in 2 Register unterteilt (also TX und Receive)? Wenn ja, wie
> unterscheidet man beim Zugriff die beiden Register?

Ganz einfach: das eine wird gelesen, das andere wird geschrieben.

> 3. Wie modifiziere ich das Programm, dass es die gwünschten Funktionen
> erfüllt? Ich habe ja ein schlechtes Gewissen

Das solltest du auch haben. Aber weniger deswegen, sondern weil du kein 
C Buch hast, in dem du die Grundlagen der STringverarbeitung gelesen, 
geübt und gelernt hättest.

[Karl H. (kbuchegg)]

Dido schrieb:
> spess53 schrieb :
>> Hi
>>
>>>UCSR0B|= (1<<TXEN0) |(1<<RXEN0) | (1<<RXCIE0) | (TXCIE0) | (UDRIE0)
>>                                                  ^^^^^^^^   ^^^^^^^^
>>
>> Das solltest du dringend ändern. Allerdings fehlen die zugehörigen ISRs.
>>
> Upss Flüchtigkeitsfehler. Jap die ISRs fehlen, hab ich aber erstmal
> aktiviert, für den Fall das ich sie doch brauche :)

Schlechte Idee.

Gibst du einen Interrupt frei, für den es keine ISR gibt, und tritt die 
Interruptsituation auf, dann wird das mit einem Prozessorreset bestraft.

Ausserdem. Sieh erst mal zu, dass du so klar kommst. Interrupts kommen 
später. Irgendwann. Vielleicht nächstes Jahr. Bis dahin hast du noch 
tausende andere Themen, die wichtiger sind. Wie zb: Wie funktionieren 
eigentlich Strings in C?