strtok, strtol ersetzen durch sparsamere Varianten

[Heribert (Gast)]

Hallo,

mal eine kurze Frage in die Runde. Gibt es irgendwo eine Code-Sammlung, 
wo man alternative Funktionen findet, die deutlich weniger Flash/RAM 
brauchen?

Ich habe zum Beispiel hier das Problem, dass diese doch recht kurze 
Funktion einen riesigen Speicherzuwachs verursacht.

  const char delimiter[] = ",;:";      // Trennzeichen
  const unsigned char SIZE_OF_DATA = 5;  // Maximal zu empfangende Datenfelder
  unsigned char data[SIZE_OF_DATA];    // Speicher Datenfelder
  unsigned char ct = 0;

  char* ptr = (char*)strtok((char*)USART0_string, delimiter);
  while(ptr != NULL && ct < SIZE_OF_DATA)
  {
    data[ct++] = strtol(ptr, NULL, 16);
    ptr = strtok(NULL, delimiter);
  }

Ich empfange auf einem Attiny einen String, der immer wie folgt aussieht

char buffer[] = "01:02:0f:0F:FF\n";

Nun habe ich das in meiner Anweisung bislang so gemacht,
das ich jedes Mal eine Zeichenkette bis zum Auftreten des Trennzeichens 
einlese. Die Zeichenkette (in meinem Fall im 2 Zeichen lang + '\0') wird 
dann mit strtol in eine Zahl umgewandelt zur Basis 16. Anschließend 
landet diese in einem Zahlenarray. Sollten einmal, wieso auch immer mehr 
Datenfelder eingelesen werden, so werden die weiteren ignoriert.

Kennt jemand dazu eine smarte Alternative?

[DirkB (Gast)]

Benutze endptr von strtol

  char *endptr;
  char* ptr = (char*)USART0_string;
  do
  {
    data[ct++] = strtol(ptr, &endptr, 16);
    ptr = endptr+1;
  }
  while(*endptr == ':' && ct <= SIZE_OF_DATA)

oder so (weil ungetestet)
Geht aber nur, wenn der : direkt hinter der Zahl steht.

[Heribert (Gast)]

Hallo Dirk,

danke schon einmal für den Tipp. So funktionierte es nicht direkt. Gab 
aber keine Compilerwarnung, werde es gleich noch einmal weiter testen. 
Es würde auf jedenfall schon mal ein kleines bisschen am Speicher 
sparen.

Würde aber gerne komplett auf string.h und stdlib.h verzichten können. 
Das ist die einzige Stelle im ganzen Programm, wo ich das benötige.

[Frank M. (ukw) (Moderator)]

Ich habe aus dem obigen Code-Schnipsel mal ein Programm gemacht, welches 
einfach auf einem PC (Linux, Windows) übersetzbar ist:

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

char buffer[] = "01:02:0f:0F:FF\n";

int main ()
{
    const char delimiter[] = ",;:";      // Trennzeichen
    const unsigned char SIZE_OF_DATA = 5;  // Maximal zu empfangende Datenfelder
    unsigned char data[SIZE_OF_DATA];    // Speicher Datenfelder
    unsigned char ct = 0;

    char* ptr = buffer;

    while(ptr != NULL && ct < SIZE_OF_DATA)
    {
        data[ct++] = strtol(ptr, NULL, 16);
        ptr = strtok(NULL, delimiter);
    }

    printf ("%s%02x:%02x:%02x:%02x:%02x\n", buffer, data[0], data[1], data[2], data[3], data[4]);

    return 0;
}

Output:

01:02:0f:0F:FF
01:01:00:00:00

Manchmal ändert sich die 2. Zeile auch.

Fazit: Das Programm tut überhaupt nicht, was es soll. Wurde das 
überhaupt mal getestet?

Alternative ohne die Kanonen auf Spatzen (strtok & strtol) folgt 
gleich...

[Frank M. (ukw) (Moderator)]

Und hier die platzsparende und schnellere Variante, die ohne strtok() 
und strtol() auskommt:

#include <stdio.h>
#include <stdint.h>

/*---------------------------------------------------------------------------------------------------------------------------------------------------
 * htoi: convert n hex digits (max is 4) of a string into decimal value
 *---------------------------------------------------------------------------------------------------------------------------------------------------
 */
uint16_t
htoi (char * buf, uint8_t max_digits)
{
    uint8_t     i;
    uint8_t     x;
    uint16_t    sum = 0;

    for (i = 0; i < max_digits && *buf; i++)
    {
        x = buf[i];

        if (x >= '0' && x <= '9')
        {
            x -= '0';
        }
        else if (x >= 'A' && x <= 'F')
        {
            x -= 'A' - 10;
        }
        else if (x >= 'a' && x <= 'f')
        {
            x -= 'a' - 10;
        }
        else
        {
            x = 0;
        }
        sum <<= 4;
        sum += x;
    }

    return (sum);
}


char buffer[] = "01:02:0f:0F:FF\n";

int main ()
{
    const unsigned char SIZE_OF_DATA = 5;  // Maximal zu empfangende Datenfelder
    unsigned char data[SIZE_OF_DATA];    // Speicher Datenfelder
    unsigned char ct = 0;

    char* ptr = buffer;

    while (*ptr)
    {
        data[ct++] = htoi (ptr, 2);
        ptr += 3;
    }

    printf ("%s%02x:%02x:%02x:%02x:%02x\n", buffer, data[0], data[1], data[2], data[3], data[4]);

    return 0;
}

Output:
01:02:0f:0F:FF
01:02:0f:0f:ff

Passt also.

Voraussetzung ist aber, dass der TO das Format von Buffer 
("xx:xx:xx:xx:xx\n") vorher prüft. Sonst geht das hier in die Hose.

[Sicher (Gast)]

Ich empfehl die Substitution zu Laengenenthaltenden Strings. Dh, dass 
das erste Byte die Laenge < 256 enthaelt. Macht vieles einfacher.

[DirkB (Gast)]

@Frank M.

In deinem ersten Beispiel fehlt der initiale Aufruf von strtok (da ist 
der erste Paramter != NULL)

[Frank M. (ukw) (Moderator)]

DirkB schrieb:
> @Frank M.
>
> In deinem ersten Beispiel fehlt der initiale Aufruf von strtok (da ist
> der erste Paramter != NULL)

Stimmt, Du hast recht, den habe ich versehentlich gelöscht.

Nichtsdestotrotz: Meine gepostete Alternative ist kürzer und schneller 
:-)

[Stefan S. (sschultewolter)]

Hallo Frank,

klasse Ansatz. Hab mir deine Idee auch erst einmal direkt abgespeichert. 
Habe es bei mir ähnlich gelöst mit string und stdlib, da es mir so im 
Buch auch nicht anders erklärt wurde. Leider findet meisten keine 
Alternativen und muss die selber schreiben.

Ich werde deine Idee mal versuchen aufzuarbeiten. Habe auch immer einen 
String, den ich splitten muss. Bekomme aber ab und zu ein paar falsche 
Werte rein. Mal schaun ob ich das evtl. etwas passend umschreiben kann 
;)

Werd dann meinen Ansatz hier auch noch mit reinstellen.

[Lukas K. (carrotindustries)]

Woher kommt eigentlich dieses Märchen, dass alles was aus der libc kommt 
aufgeblasen ist?

Mal das strtok von der newlib als Beispiel: 
https://sourceware.org/git/gitweb.cgi?p=newlib-cygwin.git;a=blob_plain;f=newlib/libc/string/strtok_r.c;hb=HEAD

[Stefan S. (sschultewolter)]

Hab das ganze mal etwas umgeschrieben, etwas statisch, aber sollte nicht 
das Problem sein.

Mit

// CMD_ERROR == 0x00
uint8_t checkCommand(char *str)
{
  const uint8_t MAX_STRLEN = 11;
  uint8_t ct = 0;
  
  while(*str != '\0')
  {
    if(ct%3 != 2)
    {
      if(!
      ((*str >= 'a' && *str <= 'f') ||
      (*str >= 'A' && *str <= 'F') ||
      (*str >= '0' && *str <= '9'))

      ) return CMD_ERROR;
    }
    else
    {
      if(*str != ':') return CMD_ERROR;
    }
    ct++;
    *str++;
  }
  if(ct != MAX_STRLEN) return CMD_ERROR;
  else return 1;
}

wird überprüft, ob der String = "xx:xx:xx:xx" entspricht.

Wenn diese Funktion 1 zurückgibt, kann splitCommand genutzt werden.

void splitCommand(char *str, uint8_t *data, uint8_t SIZE_DATA)
{
  uint8_t ct = 0;
  char* ptr = str;
  while(*ptr && ct < SIZE_DATA-1)
  {
    data[ct++] = htoi(ptr, 2);
    ptr += 3;
  }
}

Scheint soweit zu gehen.