Uart Zeichen auslesen

[Anfänger (Gast)]

Hallo ich habe eine Frage zum Uart, wenn ich eine Zeichenkette 
eingesesen habe und diese gespeichert wurde, kann man dann das 
gespeicherte Byte auf PORTB des MC ausgeben?
Ich arbeite mit einem ATmega16 in C mit 4MHz und 4800 bps.
Den Quelltext habe ich aus dem AVR Tutorial ich bin mir aber nicht 
sicher
das der Quelltext zu 100% richtig ist er hat zumindest kein error.
Danke an alle die sich die Mühe machen mir zuhelfen.

#include <stdlib.h>
#include <avr/io.h>  
#include <util/delay.h>
#include <inttypes.h>
#define F_CPU 4000000L
#define BAUD 4800L
#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )


uint8_t uart_getc(void);
void initusart ();
void uart_gets( char* Buffer, uint8_t MaxLen );

int main(void)
{
  void initusart ();
  uint8_t uart_getc(void);
  void uart_gets( char* Buffer, uint8_t MaxLen );
}

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

//Zeichen sammeln und zum String zusammen setzen
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();
  }
}


//UART Initialisieren
void initusart ()
{

    UBRRH = ubrr_value >> 8;
    UBRRL = ubrr_value & 0xFF;

  UCSRB |= (1<<RXEN)|(1<<RXCIE);              // UART RX einschalten  
  UCSRC = (1<<URSEL)|(111<<UCSZ1)|(00<<UPM1)|(1<<UPM0)|(0<<USBS ); // Asynchron 8 Bite 
 
}

[Anfänger (Gast)]

sorry unter main muss noch eine Schleife habe ich vergessen.

while (1)
{


}

[ich (Gast)]

Irgenwie passt "Zeichenkette" und "kann man dann das gespeicherte Byte 
auf PORTB des MC ausgeben" nicht zusammen??
Die Ausgabe fehlt ja völlig, darum kann man ja auch nicht sehen, was du 
genau willst.

Und vielleicht nochmal in die Grundlagen von C reingucken, wie das mit 
den Funktionen und der Variablenübergabe geht, da stimmt so einiges 
nicht. Es wird nix gespeichert. Zusammenkopieren alleine löst deine 
Aufgabenstellung nicht.

[Anfänger (Gast)]

Ja aber was will man machen wenn man keine Ahnung hat, ich muss das 
fertig machen und habe keine Zeit mir noch mal alle c Grunglagen durch 
zulesen.

void initusart ();

habe ich schon in:

initusart ();

geändert und jetzt geht es.

void uart_gets( char* Buffer, uint8_t MaxLen );

hir bin ich mir noch nicht sicher wie ich das ändern muss

[Anfänger (Gast)]

int main(void)
{
  initusart ();
  uint8_t uart_getc(void);
  void uart_gets( char* Buffer, uint8_t MaxLen );
}

//Zeichen sammeln und zum String zusammen setzen
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();
  }
}

kann mir jemand sagen wie ich
void uart_gets( char* Buffer, uint8_t MaxLen );
in main ändern muss damit ich die Funktion die dahinter steckt aufrufen 
kann.

[Mano W. (Firma: ---) (manow)]

>Hallo ich habe eine Frage zum Uart, wenn ich eine Zeichenkette
>eingesesen habe und diese gespeichert wurde, kann man dann das
>gespeicherte Byte auf PORTB des MC ausgeben

Was willst Du machen? Welches gespeicherte Byte willst Du aus der 
Zeichenkette ausgeben? Wie könnte denn deine Zeichenkette aussehen?

>Und vielleicht nochmal in die Grundlagen von C reingucken, wie das mit
>den Funktionen und der Variablenübergabe geht, da stimmt so einiges
>nicht. Es wird nix gespeichert. Zusammenkopieren alleine löst deine
>Aufgabenstellung nicht.

Dem kann man nur recht geben

[Anfänger (Gast)]

z.B.  00010011 dann 00101001 dann 0011010

insgesamt werden 10 Byte in den Uart geladen

[Anfänger (Gast)]

>Dem kann man nur recht geben
Ja ihr habe ja recht aber ich kann mir das auch nicht an 1 Tag alles bei 
bringen.

[ich (Gast)]

Man kann dir nicht helfen, da man nicht weiß was du willst!!
Da steht einerseits irgendwas mit Zeichenkette und gleichzeitig das 
gespeicherte Byte ausgeben. Ja aber eine Zeichenkette besteht aus vielen 
Bytes, so ist es sehr schwer zu erahnen welches du den gern hättest!!!

[Mano W. (Firma: ---) (manow)]

>insgesamt werden 10 Byte in den Uart geladen

Wie würde dann die main-Funktion ausschauen, da fehlt doch was.

>void uart_gets( char* Buffer, uint8_t MaxLen );

Welche Parameter braucht diese Funktion?

[Anfänger (Gast)]

Ja sorry wenn ich euch durch einnander gebracht habe.
Ich möchte die eingelesenen Byte z.B.00010011 00101001 0011010 auf den 
Ausgang PORTB ausgeben. Wenn die z.B. 00010011 eingelesen wurde soll auf 
PORTB 0=0 erscheinen und wenn das nächste Byter kommt soll
PORTB 1=0
PORTB 2=0
PORTB 3=1
PORTB 4=0
PORTB 5=0
PORTB 6=1
PORTB 7=1

auf PORTB halt das nöchste Byte angszeigt werden.

[Anfänger (Gast)]

Hallo ich habe noch ein wenig an mein Quelltext verändert und das 
Initalisieren geht jetzt aber die zweite Funktion unter main wird immer 
noch nicht aufgerufen. Kann mir denn nicht jemand den Quelltext anpassen 
so das ich 8 Byte + 1 Stoppbite empfangen kann.


[c] #include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>
#include <inttypes.h>
#define F_CPU 4000000L
#define BAUD 4800L
#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )

uint8_t uart_getc(void);
void initusart ();
void uart_gets( char* Buffer, uint8_t MaxLen );

//*************************  main   ***************************

int main(void)
{

DDRB = 0xff;

  while (1)
  {
    initusart ();
    void uart_gets( char* Buffer, uint8_t MaxLen );
  }
}


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


//***********************Zeichen sammeln und zum String zusammen 
setzen******
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();
  }
}




//******************UART Initialisieren**********************
void initusart ()
{

    UBRRH = ubrr_value >> 8;
    UBRRL = ubrr_value & 0xFF;

  UCSRB |= (1<<RXEN)|(1<<RXCIE);              // UART RX einschalten
   UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);// Asynchron 8 
Bite

}

[Anfänger (Gast)]

So jetzt kann ich alle funktinen aufrufen.

  #include <stdlib.h>
#include <avr/io.h>  
#include <util/delay.h>
#include <inttypes.h>
#define F_CPU 4000000L
#define BAUD 4800L
#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )

// Prototypen
uint8_t uart_getc(void);
void initusart ();
void uart_gets( char* Buffer, uint8_t MaxLen );

//********************  main   *********************

int main(void)
{

  // Variablen

  char strBuffer[256];

  DDRB = 0xff;
  initusart ();   
  
  
  while (1)
  {
    
    
    //DDRA = 0xff;

    // void uart_gets( char* Buffer, uint8_t MaxLen )
    uart_gets( &strBuffer[0], 255 );  //void
  }
}


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


//********Zeichen sammeln und zum String zusammen setzen******
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();
  }
}




//***************UART Initialisieren********************
void initusart ()
{

    UBRRH = ubrr_value >> 8;
    UBRRL = ubrr_value & 0xFF;

  UCSRB |= (1<<RXEN)|(1<<RXCIE);              // UART RX einschalten   
   UCSRC = (1 << URSEL) | (1 << UCSZ1) | (1 << UCSZ0);// Asynchron 8 Bite 

}

[Anfänger (Gast)]

So mit dem Quelltext kann ich Daten empfangen und wenn man UDR (unter 
uint8_t uart_getc(void))  auf einen Ausgang gibt kann man auch die Bits 
sehen die empfangen wurden.