UART byte einlesen

[Anfänger (Gast)]

Hallo ich habe eine Frage, wie kann ich 14 Byte die ich nach einander 
gesendet bekomme in 14 Variable laden. Alles was ich versucht habe geht 
nicht.

C-Code

//************************   Empfangen von Daten   *******
#include <stdlib.h>
#include <avr/io.h>
#include <util/delay.h>
#include <inttypes.h>
#define F_CPU 16000000L
#define BAUD 2400L
#define ubrr_value (  ( F_CPU / (16*BAUD) ) - 1  )

// Prototypen
uint8_t uart_getc(void);
void initusart ();
void uart_gets( char* Buffer, uint8_t MaxLen );
unsigned char adresse[15];
unsigned char adresse1[15];
unsigned char freigabe[15];
unsigned char messwerte[15];
int iffreigabe;
//********************  main   *********************
int daten(void)
{
  char strBuffer[14];
  DDRB = 0xff;
  initusart ();


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


}
/************************ Zeichen empfangen *******************/
uint8_t uart_getc(void)
{
lcd_string("Lesen");

while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar



  //14 Byte in die Variabele abresse 1-14 einlesem


adresse[1] = UDR;
adresse[2] = UDR;
adresse[3] = UDR;
adresse[4] = UDR;
adresse[5] = UDR;
adresse[6] = UDR;
adresse[7] = UDR;
adresse[8] = UDR;
adresse[9] = UDR;
adresse[10] = UDR;
adresse[11] = UDR;
adresse[12] = UDR;
adresse[13] = UDR;
adresse[14] = UDR;













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();

  while( NextChar != '\n' && StringLen < MaxLen - 1 )
  {
    *Buffer++ = NextChar;
    StringLen++;

    NextChar = uart_getc();
  }
}




//***************UART Initialisieren********************
void initusart ()
{
  UBRRH = (unsigned char)(ubrr_value>>8);
    UBRRL = (unsigned char)ubrr_value;

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




  UCSRB = (1<<RXEN)|(1<<TXEN);// UART RX einschalten
  UCSRC = (1<<URSEL)|(1<<UCSZ1)|(1<<UCSZ0);

}
[/c]

[Klausy (Gast)]

Du musst die Bytes schon nacheinander Auslesen...

while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar

adresse[1] = UDR;

while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar

adresse[2] = UDR;

[Anfänger (Gast)]

Und wie kann ich es machen das erst in adresse[1] eingelesen wir wenn 
eines der Byte 0001 und die letzten 4 Bite sind egal die können sich 
verändern.

[Klausy (Gast)]

char  my_rec_byte, my_byte_count;
bit  my_Start_rec_flag;

do
{
 while (!(UCSRA & (1<<RXC)));   // warten bis Zeichen verfuegbar

 my_rec_byte = UDR;

 if(my_rec_byte &= 0b00010000)
 {
  my_Start_rec_flag = 1;
 }

if( my_Start_rec_flag)
 {
  my_byte_count++
  adresse[my_byte_count] = my_rec_byte;
 }

}while( my_byte_count != 15);

my_byte_count = 0;
my_Start_rec_flag = 0;

[Sven P. (Gast)]

Punkt eins: Das Forum hier kann C-Code hervorheben.

Punkt zwei:
Anfänger wrote:
> Und wie kann ich es machen das erst in adresse[1] eingelesen wir wenn
> eines der Byte 0001 und die letzten 4 Bite sind egal die können sich
> verändern.

Und wie kann ich machen dass bummsfallera und lalala di düdel di do 
abbel-äh.

Punkt drei:
Der Code ist Bockmist von vorne bis hinten. Erst ist er unvollständig 
und dann machen die Funktionen alles, nur nicht das, was sie eigentlich 
tun sollen:
- "uart_getc" (UART get char) liest statt einem Zeichen gleich fünfzehn 
ein
- "uart_gets" (UART get string) liest alles, aber keinen C-String, denn 
der müsste mit \0 beendet werden
- UBRR wird falsch initialisiert.
- Vektoren werden im Übrigen von 0 an gezählt

[Anfänger (Gast)]

Das ist das Problem in Deutschland nur meckern und schimpfen, aber es 
nicht besser machen danke Sven Pauli. Es tut mir leit das ich nicht so 
gut Programieren kann um deinen hohen Ansprüchen zugenügen.

[Anfänger (Gast)]

@ Klausy danke für deine Hilfe! Habe ich dein Quelltext richtig 
verstanden?

Es wird gewartet bis ein Byte da ist dann wird das Byte in my_rec_byte 
geschreiben und wenn an der stelle 3 eine 1 ist wird die Startvariable 
freigegeben. Ist die Startvariable freigegeben wird der counter eins 
weiter gestellt und in adresse[] kommt eine 1 und die Variable wird mit 
my_rec_byte beschrieben. Zum schluss wird 14 mal gezählt und dann nach 
Byte 14 gestoppt.

[Sven P. (Gast)]

Anfänger wrote:
> Das ist das Problem in Deutschland nur meckern und schimpfen, aber es
> nicht besser machen danke Sven Pauli. Es tut mir leit das ich nicht so
> gut Programieren kann um deinen hohen Ansprüchen zugenügen.

Hach ich liebe diese Freds. Zum mitmeißeln:
Du rotzt hier eine lustlose Frage ohne Punkt und Komma hin und hängst 
einen so nicht funktionierenden, da unvollständigen, Quelltext dazu, 
obwohl schon zum hunderttausendsten gesagt wurde, dass Copy&Paste&Post 
nix bringt, sondern vollständige Quelltexte gefordert sind. BASTA. Der 
Quelltext darf ja auf das Wesentliche reduziert sein, aber er sollte 
trotzdem vollständig und kompilierbar sein.

Dann macht man dich auf fundamentalste Fehler im Quelltext aufmerksam 
(wärs dir lieber, ich würde dir das Zeugs schönreden, damit du das 
nächste Mal wieder auf die Schnauze fällst?). Also nochmal:

* UBBR ist immer noch falsch initialisiert.
-> Der GCC teilt eine Zuweisung an UBBR automatisch in UBBRH und UBBRL 
auf.
* Funktionen haben nicht ohne Grund Namen.
-> Denk mal drüber nach.
* Vektoren werden immer noch von Null an gezählt.

Im Übrigen brauchts dir nicht Leid zu tun, noch nicht so weit mit dem 
Programmieren zu sein. Verbesser doch ersteinmal einfach, was ich dir da 
angekreidet hab, wie wärs?

Wenn das zu hart rüberkommt, tuts mir ja Leid drum, aber zeig doch 
wenigstens, dass du an einer Antwort interessiert bist, zum Beispiel, 
indem du deine Fragen ordentlich formulierst, das gibt den Beteiligten 
hier wenigstes das Gefühl, dass es dir nicht total scheißegal ist, ob 
sich jemand deiner Probleme annimmt.

[Anfänger (Gast)]

>>* UBBR ist immer noch falsch initialisiert.
>>-> Der GCC teilt eine Zuweisung an UBBR automatisch in UBBRH und UBBRL
>>auf.

aber ich kann Daten einlesen also kann es ja nicht ganz falsch sein

>>* Funktionen haben nicht ohne Grund Namen.
>>-> Denk mal drüber nach.

und was meinst du damit

>>* Vektoren werden immer noch von Null an gezählt.

aber von 1 an geht das auch und ich komme nicht durch einander

[Sven P. (Gast)]

Anfänger wrote:
>>>* UBBR ist immer noch falsch initialisiert.
>>>-> Der GCC teilt eine Zuweisung an UBBR automatisch in UBBRH und UBBRL
>>>auf.
>
> aber ich kann Daten einlesen also kann es ja nicht ganz falsch sein
Das ist auch nicht ganz falsch, nur umständlich.

>>>* Funktionen haben nicht ohne Grund Namen.
>>>-> Denk mal drüber nach.
>
> und was meinst du damit
Wenn du eine Funktion namens "getc", also "get char" nennst, dann soll 
die doch ein Zeichen einlesen, und nicht gleich fünfzehn.


>>>* Vektoren werden immer noch von Null an gezählt.
>
> aber von 1 an geht das auch und ich komme nicht durch einander
Das geht auch, aber du verschenkst dabei immer Speicherplatz. Und du 
brauchst umständlichere Rechnungen bei Schleifen. Außerdem bekommst du 
probleme, wenn du mal einen Vektor an eine Funktion aus der libc 
übergeben möchtest, die zählt nämlich natürlich und von Null an.


Auf der einen Seite sagst du, du bist noch nicht so ein guter 
Programmierer, und auf der andren meinst du zu den Problemen immer "es 
geht, also ists richtig" oder "aber das geht auch so". Lerns doch 
richtig und erfinde nicht immer das Rad neu.

[Severino R. (severino)]

Sven Pauli wrote:

> Hach ich liebe diese Freds.

Sven liebt Fred?
Welchen Fred, Fred Feuerstein (engl. Flintstone)?

SCNR