Frage zur seriellen Eingabe (Buffer)

[Thomas P. (newi)]

Hallo Leute,
ich habe mal eine Frage an euch. Den unten stehenden Code verwende ich 
um Zeichenketten einzulesen. Meine Frage, wie kann ich aus dem ZEiger 
*Buffer nun meine eingelesene Zeichenkette weiterverarbeiten?
Ich habe vor Telefonnummern und deren zugehöhrige Daten in ein Array zu 
speichern. ...Fang mal klein an, mit einer Nummer. Ich habe aber keine 
Ahnung wie ich diese nach dem Einlesen in eine Variable speichern kann.

Wäre echt gut wenn mir hier einer auf die Sprünge helfen kann!
Danke

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



void uart_gets1( 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';

}

[Thomas P. (newi)]

kann mir keiner helfen?

[bla (Gast)]

Hoi.

Du liest einzelne Zeichen vom Typ char ein. Ein String ist im Prinzip 
nur ein Chararrey. Wenn du nun diese Strings Speicheren möchtest, 
erstellst du ein Pointerarray ( char*array[anzahl der nummern] ). Da 
kannst du dann deine Strings mit strcpy() reinkopieren:

    char*string;
    char*stringarray[1];
    string="Hallo\0";
    strcpy(stringarray[0],string);

Wenn du die einzelnen Zeichen in Integerwerte umrechnen möchtest, musst 
du von deinem Zeichen das Zeichen '0' abziehen. Damit hast du dann den 
Dezimalwert. Nun musst du diesen mit 10^(Anzahl Stellen - Stelle des 
Zeichens im String) multiplizieren und hinterher Aufsummieren.

...

[Stefan B. (stefan)]

Da fehlt der Aufruf der Einlesefunktion. Diese Aufruferfunktion hat 
mehrere Jobs:

1/ Ggf. einen ausreichend Puffer grossen bereitstellen (wenn es kein 
globaler Puffer ist) und dessen Adresse und Fassungsvermögen zum 
Befüllen an die Einlesefunktion übergeben.

2/ Den ggf. gefüllten Puffer auseinanderschnippeln. Wie zu schnippeln 
ist, hängt von den darin befindlichen Daten ab.

Beispiel #1

Name Vorname [phone]

wäre schwieriger zu schnippeln (Neumann Alfred E. [phone]) als

Beispiel #2

NAME="Name", VORNAME="Vorname", NUMMER="[phone]"

Bei Beispiel #2 kännte man sich auf Trennzeichen (,) stützen und den 
Text zwischen den "" den enstprechenden Feldern (dem Text vor dem =) 
zuordnen.

Funktionen zum Auseinanderschneiden von Strings finden sich in der Doku 
zur Headerdatei /strings.h/ oder in der Forensuche mit strtok and 
friends.

[Karl H. (kbuchegg)]

bla schrieb:
> Hoi.
>
> Du liest einzelne Zeichen vom Typ char ein. Ein String ist im Prinzip
> nur ein Chararrey. Wenn du nun diese Strings Speicheren möchtest,
> erstellst du ein Pointerarray ( char*array[anzahl der nummern] ). Da
> kannst du dann deine Strings mit strcpy() reinkopieren:
>
>     char*string;
>     char*stringarray[1];
>     string="Hallo\0";
>     strcpy(stringarray[0],string);


Autsch.
So auf keinen Fall!

Du kannst nicht einfach Pointer benutzen um dorthin zu schreiben wie du 
lustig bist. Du brauchst am Ziel schon auch reservierten Speicher!

[Karl H. (kbuchegg)]

Thomas P. schrieb:

> um Zeichenketten einzulesen. Meine Frage, wie kann ich aus dem ZEiger
> *Buffer nun meine eingelesene Zeichenkette weiterverarbeiten?

Merke:
nur weil die Funktion einen Pointer als Argument bekommt, heißt das 
nicht, das der Aufrufer nur eine Pointervariable benötigt.

Du musst deine Funktion uart_gets1 so benutzen

int main()
{
  char KompletteZeile[80];    // Annahme: es werden nicht mehr als 80 Zeichen gebraucht

  ...

  uart_getsl(  KompletteZeile, sizeof( KompletteZeile ) );

  ...
  // ab hier hast du dann den String im Array vorliegen und kannst mit
  // den C-Stringfunktionen darauf arbeiten
}

Siehe auch
http://www.mikrocontroller.net/articles/FAQ#Wie_funktioniert_String-Verarbeitung_in_C.3F
für eine kurze Einführung in Stringverarbeitung. Näheres und wesentlich 
umgfangreicheres weiß dein C-Buch darüber zu berichten

[bla (Gast)]

Karl heinz Buchegger schrieb:
> bla schrieb:
>> Hoi.
>>
>> Du liest einzelne Zeichen vom Typ char ein. Ein String ist im Prinzip
>> nur ein Chararrey. Wenn du nun diese Strings Speicheren möchtest,
>> erstellst du ein Pointerarray ( char*array[anzahl der nummern] ). Da
>> kannst du dann deine Strings mit strcpy() reinkopieren:
>>
>>     char*string;
>>     char*stringarray[1];
>>     string="Hallo\0";
>>     strcpy(stringarray[0],string);
>
>
> Autsch.
> So auf keinen Fall!
>
> Du kannst nicht einfach Pointer benutzen um dorthin zu schreiben wie du
> lustig bist. Du brauchst am Ziel schon auch reservierten Speicher!

Guck doch mal genauer hin verdammt. Zwischen string="Hallo\0" und strcpy 
steht doch eindeutig
stringarray[0]=(char* )malloc(strlen(string)*sizeof(char))

:-D (langen Tag gehabt)

[Karl H. (kbuchegg)]

bla schrieb:
>
> Guck doch mal genauer hin

Ich hab schon genauer hingesehen (das ist aber auch klein gedruckt :-)

> verdammt.

Die einzige Sprache, die alle Programmierer perfekt beherrschen: fluchen

> Zwischen string="Hallo\0" und strcpy
> steht doch eindeutig
> stringarray[0]=(char* )malloc(strlen(string)*sizeof(char))

Und wenn man ganz genau schaut, dann fehlt da ein +1
(dafür ist da ein Cast, der in C besser nicht da wäre :-)


> :-D (langen Tag gehabt)

LOL,