String aus ASCII Zeichen erzeugen

Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

  • String aus ASCII Zeichen erzeugen

    Hallo Leute,

    ich muß über eine RS-232 Sollwertvorgaben für einen Digitalen Signalprozessor einlesen. Da der DSP mit einer Festkommaarithmetik arbeitet muß ich die Daten in festgelegte Formate umwandeln. Dazu gibts auch eine Funktion in einer Bibliothek des DSPs, die einen string aus ASCII Zeichen in eine Festkommazahl umwandelt, diese benötigt einen Zeiger auf den String als Argument. Da hab ich mir gedacht benutz mal strcat um die Daten aus dem Lesepuffer an den String anzuhängen, leider wird nur das erste übertragene Zeichen angehangen.
    Das ganze wird Interrupt gesteuert aufgerufen, wenn daten ankommen wird der Puffer(1 byte) gelesen und dann beim nächsten Paket wieder.

    hier ist mal ein teil des Quellcodes:

    Quellcode

    1. char rdata[];
    2. rdata[0] = 0;
    3. ...
    4. if(ticker1 == '8') // '8' wegen der smilies ;-)
    5. {
    6. Qs_ref=_atoIQ(&rdata); //Funktion zur Stringkonvertierung
    7. ticker1 = 0;
    8. }
    9. ...
    11. //Teil des receive Interrupts
    12. Uint16 i;
    13. ticker1++;
    14. for(i=0;i<1;i++)
    15. {
    16. rdataA[i]=SciaRegs.SCIRXBUF.all; //Einlesen
    17. strcat(rdata, rdataA[i]);
    18. }
    Alles anzeigen


    Ich möchte eigendlich 8 Zeichen übertragen und dann konvertieren.

    Ich bin zugegebener Maßen kein C-Kenner und hoffe hier den passenden Denkanstoß zu bekommen.

    Bin für jede Hilfe dankbar!!

    Gruß
    Florian

  • rdata soll dein 8 byte großer Puffer für den String sein?
    dann kannst du mit char auch ein 8 byte großes array nehmen statt ein byte:
    char rdata[8];
    rdata[0] = 0; Du willst den Inhalt "nullen":
    um das ganze char array zurückzusetzen kannste memset benutzen:
    memset(rdata, '\0', sizeof(rdata));
    was ticker1 sein soll weiss ich leider nicht.
    Diese Schleife:

    Quellcode

    1. for(i=0;i<1;i++)
    2. {
    3. rdataA[i]=SciaRegs.SCIRXBUF.all; //Einlesen
    4. strcat(rdata, &rdataA[i]);
    5. }

    Läuft genau 1 mal durch. Ergo wird auch nur ein Zeichen eingelesen und danach an rdata angehängt. Ist rdataA nicht nur ein Zeichen? Wozu brauchst du dann den Index?
    Ich würde sowas hier machen:

    Quellcode

    1. for(i=0;i<8;i++) // 8 Durchläufe
    2. {
    3. if(SciaRegs.SCIFFRX.bit.RXFIFST > 0)//Falls was zu lesen ist
    4. rdata[i]=SciaRegs.SCIRXBUF.all; // schreibs in rdata
    5. }

    dann kannst du dir rdataA sparen.
    das "if(SciaRegs.SCIFFRX.bit.RXFIFST > 0)" hab ich im Netz gefunden. Wenns bei dir nicht klappt kannstes ja rausschmeissen.
    Hoffe das geht auch so, kanns nicht ausprobieren ;)

  • Erstmal danke @newb.

    Also rdata soll die zeichenkette aufnehmen.
    Ist die dekleration mit

    char rdata[];

    nicht eine Zeichenkette mit unbestimmter Länge??
    Der Puffer ist der scibuf, dieser fasst ein byte. ticker1 brauche ich um nach 8 empfangenen Zeichen die umwandlung in die Festkommazahl durchzuführen

    siehe
    if(ticker1 == '8') // '8' wegen der smilies Wink
    {
    Qs_ref=_atoIQ(&rdata); //Funktion zur Stringkonvertierung
    ticker1 = 0;
    }

    Die schleife

    for(i=0;i<1;i++)
    {
    rdataA=SciaRegs.SCIRXBUF.all; //Einlesen
    strcat(rdata, rdataA[i]);
    }
    wird immer dann ausgeführt wenn ein Zeichen empfangen wird, das geschieht durch den Interrupt. Daher ist das mit dem einmal durchführen o.k. bei jedem durchlauf soll ja an die globale Variabele "rdata" mit strcat das nächste Zeichen angehangen werden. Die zuordnung rdata[0]=0 mache ich weil strcat nur funktioniert wenn mind ein Zeichen in rdata steht!???!
    Ich denke das mein Fehler irgendwie in der Deklaration von rdata oder in der Zuweisung von rdata[i] an rdata steckt.
    Muß ich rdata eventuell auch indizieren??




    Quellcode

  • "Florian79" schrieb:

    Ist die dekleration mit

    char rdata[];

    nicht eine Zeichenkette mit unbestimmter Länge??

    ja und nein ;)
    char hallo[] = { "Teststring\n" };
    damit wird ein char array von der Länge des Strings in den geschweiften Klammern angelegt (11 + \0). Sobald du aber 12 oder mehr Zeichen reinschreiben willst gibts nen Überlauf. Er verwaltet sich nicht selbst im Gegensatz zu der string-Klasse in C++.

    "Florian79" schrieb:

    Der Puffer ist der scibuf, dieser fasst ein byte. ticker1 brauche ich um nach 8 empfangenen Zeichen die umwandlung in die Festkommazahl durchzuführen
    [...]
    Die schleife

    for(i=0;i<1;i++)
    {
    rdataA=SciaRegs.SCIRXBUF.all; //Einlesen
    strcat(rdata, rdataA[i]);
    }
    wird immer dann ausgeführt wenn ein Zeichen empfangen wird, das geschieht durch den Interrupt. Daher ist das mit dem einmal durchführen o.k. bei jedem durchlauf soll ja an die globale Variabele "rdata" mit strcat das nächste Zeichen angehangen werden.

    Ok.

    "Florian79" schrieb:

    Die zuordnung rdata[0]=0 mache ich weil strcat nur funktioniert wenn mind ein Zeichen in rdata steht!???!

    Keine Ahnung ;)
    Aber ich denke nicht. es wird wohl dran gelegen haben, dass der compiler nicht wusste wie groß rdata ist.
    Und greif lieber zu strncat, da hast du mehr Kontrolle:
    strncat(rdata, &rdataA[i], 1);
    Hier wird im dritten Argument die Anzahl der anzuhängenden Zeichen angegeben.

    "Florian79" schrieb:

    Ich denke das mein Fehler irgendwie in der Deklaration von rdata oder in der Zuweisung von rdata[i] an rdata steckt.

    du meinst rdataA[i] ? Und ja, ich denke auch. Bisher hatte rdata nur Platz für ein zeichen.

    "Florian79" schrieb:

    Muß ich rdata eventuell auch indizieren??

    Nö.

  • Die zuweisung der ankommenden Datan an rdataA funtioniert.
    Wenn ich jetzt also die Deklaration so mache

    char rdata[9]; // dann hab ich doch 8 zeichen inhalt + /0 oder??

    und dann die schleife ändere in

    for(i=0;i<1;i++)
    {
    rdataA[i]=SciaRegs.SCIRXBUF.all; //Einlesen
    strncat(rdata, rdataA[i], 1);
    }

    müßten nach 8 interrups doch 8 Zeichen in rdata stehen.

    strncat sagt doch nur wieviel zeichen angehangen werden dürfen, dann müßte es auch ohne gehen weil in rdataA[i] immer nur 1 Zeichen steht, oder hat strncat noch andere Vorteile?

  • EDIT:

    "Florian79" schrieb:

    char rdata[9]; // dann hab ich doch 8 zeichen inhalt + /0 oder??

    Wir fangen bei 0 an zu zählen, also [0]-[8] sind die Zeichen und [9] ist die \0.
    Damit hast du 9 Zeichen.

    "Florian79" schrieb:

    und dann die schleife ändere in
    for(i=0;i<1;i++)
    {
    rdataA=SciaRegs.SCIRXBUF.all; //Einlesen
    strncat(rdata, rdataA[i], 1);
    }
    müßten nach 8 interrups doch 8 Zeichen in rdata stehen.

    Habs grad mal ausporbiert und man muss wohl bei ner index Angabe mit strcat/strncat die Adresse übergeben:
    strncat(rdata, &rdataA[i], 1);

    "Florian79" schrieb:

    strncat sagt doch nur wieviel zeichen angehangen werden dürfen, dann müßte es auch ohne gehen weil in rdataA[i] immer nur 1 Zeichen steht, oder hat strncat noch andere Vorteile?

    Naja, für das Beispiel müsste strcat genügen. Aber sonst ist strncat ganz hilfreich weil man da mit max_length Konstanten arbeiten kann und das erleichtert einem die Sache ungemein. Bei C Strings macht man oft Fehler weil die sich überall hinschreiben ;)

  • string.h brauchts.
    Und du musst unbedingt das array voll mit binären Nullen schreiben:

    Quellcode

    1. memset(rdata, '\0', sizeof(rdata));

    Keine normalen Nullen:

    Quellcode

    1. memset(rdata, '0', sizeof(rdata)); // falsch!

    Weil strcat hängt die Daten an, indem es die binäre Null sucht, diese rausschmeisst, die Daten anhängt und hintendran wieder ne binäre Null schreibt. Wenn diese fehlt, weiss es nicht wo es die Daten hinschreiben soll.

  • :D
    Mir is grad was unschönes aufgefallen:
    Es wäre echt besser wenn du strncat benutzt.

    Quellcode

    1. #include <string.h>
    2. #include <stdio.h>
    3. int main()
    4. {
    5. char rdata[8];
    6. char rdataA[] = "Hallo";
    7. memset(rdata, '\0', sizeof(rdata));
    8. int i;
    9. for(i=0;i<1;i++)
    10. {
    11. strcat(rdata, &rdataA[i]);
    12. }
    13. printf ("%s \n", rdata);
    14. return 0;
    15. }
    Alles anzeigen

    Dieses Beispiel zerschiesst die ganze Idee weil strcat nicht nur den Buchstaben rdataA anhängt sondern es orientiert sich ebenfalls an der \0. D.h. es hängt alles von rdataA[i] bis zur \0 an rdata. In dem Fall würde "Hallo" in rdata stehen.
    Deswegen greif doch lieber zu strncat, da biste auf der sicheren Seite und es is egal was noch alles in rdataA steht.
    Schönes Wochenende.