Commando aus String suchen..

[Jan H. (janiiix3)]

Halli Hallo,

stehe gerade irgendwie auf dem Schlauch.
Ich möchte gerne ein Kommando aus einem String raus suchen.
Übergeben tue ich der Funktionen einen String und möchte mit einem 
Zeiger Array voller Kommandos vergleichen. Ist ein Kommando mit einem 
aus dem Zeiger Array identisch, soll das übernommen werden. Wenn nicht 
soll weitergesucht werden bis alle Elemente untersucht wurden..

Bekomme es gerade nicht hin :(

unsigned int parseString(char str[], parse_t *ParseInfo,  char delimiter)
{
  #define DELIMITER_BYTE    0
  #define FIRST_COMMAND    1
  #define SECOND_COMMAND    2
  #define BEGINN_RAW_BYTE    3
  
  #define POSSIBLE_COMMANDO  ( 1<<0 )
  unsigned int tempCnt        = 0x00;
  unsigned int ptrCnt          = 0x00;

  
  while(*str != delimiter)// pointer to delimiter
  {
    str++;
    if (*str == '\0')
    return 1;
  }; 
  
  ParseInfo->receivedCmd[DELIMITER_BYTE] = *str;  
  
  while(*str)
  {
    if(*str == *ParseInfo->allowCmd[0])
    {
      printf("Erfolgreich!");
      break;  
    }
  }

  return 0;
}

delimiter soll der Anfang eines Kommandos darstellen.

[Florian (Gast)]

Hallo Jan,

was genau funktioniert denn nicht? Hat es einen Grund, warum Du keine 
Funktionen aus der string.h verwendest? Damit kannst Du Zeichen, Strings 
und Teilstrings suchen.

Gruß
Florian

[sek (Gast)]

Lass mich raten...parseString kehrt nie zurück, weil die zweiten 
while(...) Schleife nicht abbricht...

[Peter D. (peda)]

Florian schrieb:
> Hat es einen Grund, warum Du keine
> Funktionen aus der string.h verwendest?

Wie z.B. strtok, strcmp

[Jan H. (janiiix3)]

Peter D. schrieb:
> Florian schrieb:
>> Hat es einen Grund, warum Du keine
>> Funktionen aus der string.h verwendest?
>
> Wie z.B. strtok, strcmp

Suchen diese Funktionen auch mitten im String?

[Florian (Gast)]

Jan H. schrieb:
> Suchen diese Funktionen auch mitten im String?

Ja.

schau mal hier:

http://openbook.rheinwerk-verlag.de/c_von_a_bis_z/011_c_arrays_013.htm

[Dirk B. (dirkb2)]

Lass dir doch mal die Zwischenergebnisse von str ausgeben (mit printf 
oder dem Debugger)

Bei printf kannst du die noch zwischen Trennzeichen setzen, damit du 
Leerzeichen besser erkennen kannst.

printf("<%s>\n", str);

Nach der ersten while-Schleife zeigt str auf einen delimiter.
Aber damit fangen deine Kommandos sicher nicht an.

[Mmhm (Gast)]

Ich nehme gerne folgendes:

#include <string.h>

char *RX UART_RX_Buffer[0];

if(strstr(RX, "set") != NULL){
    //da seht set im RX: Kommando set ausführen
}

Must halt stat "set" einen pointer auf ein Element in deinem Array 
setzen.
strstr liefert einen pointer auf den string zurück, was praktisch ist, 
um damit weiterzuarbeiten.

Vorteil:
Portabel, weil Standarad-C-Funktion, simpel.

Nachteil:
Kein Sparwunder.

[Nop (Gast)]

Mmhm schrieb:
> Ich nehme gerne folgendes:

> char *RX UART_RX_Buffer[0];
>
> if(strstr(RX, "set") != NULL){
>     //da seht set im RX: Kommando set ausführen
> }

Normalerweise sind solche RX-Buffer ja als Ringbuffer ausgeführt. Wenn 
ein Teil des Kommandos vor dem Wraparound steht und der Rest dann am 
Anfang des Ringbuffers weitergeht, wird es nicht gefunden. Sieht mir 
also nicht nach einer zuverlässigen Lösung aus.

[asdfasd (Gast)]

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

char *find_cmd(char *str, char del, char *cmds)
{
    while (*str)
        if (*str++ == del)
            if (strchr(cmds, *str))
                return str;
    return 0;
}

int main(int argc, char **argv)
{
    char *str = ":a:b..:bb..:..:a..:";

    while (str = find_cmd(str, ':', "ab"))
        switch (*str) {
            case 'a': printf("Found a\n"); break;
            case 'b': printf("Found b\n"); break;
        }

    return 0;
}

[asdfasd (Gast)]

Ehm ... die Suche nach dem Begrenzer kann man natürlich auch mit strchr 
machen:

char *find_cmd(char *str, char del, char *cmds)
{
    while (str = strchr(str, del))
        if (strchr(cmds, *++str))
            return str;
    return 0;
}

[Mmhm (Gast)]

Nop schrieb:
> Mmhm schrieb:
>> Ich nehme gerne folgendes:
>
>> char *RX UART_RX_Buffer[0];
>>
>> if(strstr(RX, "set") != NULL){
>>     //da seht set im RX: Kommando set ausführen
>> }
>
> Normalerweise sind solche RX-Buffer ja als Ringbuffer ausgeführt. Wenn
> ein Teil des Kommandos vor dem Wraparound steht und der Rest dann am
> Anfang des Ringbuffers weitergeht, wird es nicht gefunden. Sieht mir
> also nicht nach einer zuverlässigen Lösung aus.

Das kommt drauf an, wie man die UART umgesetzt hat, und in welcher 
Umgebung.

Meine Lösung ist halt eben asynchron. Der Emfpang passiert in einer ISR, 
die befüllt den Buffer, wenn das "Stopp-Zeichen" kommt oder der Buffer 
überlaufen würde, wird ein Flag gesetzt. Überschüssige Zeichen werden 
ignoriert, statt vorhanden Daten zu überschreiben.
Die Ausführung des Kommandos passiert komplett asynchron, wenn dem 
Controller grad fad ist. Und das kann auch hunderte ms später sein. 
Danach wird der Buffer gelöscht.
Ich behaupte auch nicht dass das allgemein sinnvoller ist als andere 
Implementierungen oder ein Ringpuffer.
Aber das hier funktioniert auch dann zuverlässig, wenn der Controller 
bei 99,99% Auslastung ist.
Nachteil ist halt die begrenzte Länge einer Message.

Aber sei es wie es sei:
Das Thema war weder um UARTs, noch um Ringpuffer, sondern das finden 
eines Kommandos in einem String. Und das geht fallweise eben auch mit 
strstr.

[Jan H. (janiiix3)]

asdfasd schrieb:
>

> #include <stdio.h>
> #include <string.h>
> 
> char *find_cmd(char *str, char del, char *cmds)
> {
>     while (*str)
>         if (*str++ == del)
>             if (strchr(cmds, *str))
>                 return str;
>     return 0;
> }

>

Okay. Das klappt soweit sehr gut. Wie untersuche ich jetzt den 
"Kommando" String nach dem Ende? Habe mir gedacht das ich als 
Kommandoende das '*' Zeichen nehme?!

[Joachim B. (jar)]

mal als Beispiel ein Codeschnipsel

      if (Serial.available() > 0) 
      { char incomingByte = (char)Serial.read();
        if(incomingByte != 13 && incomingByte != 10 )  // Falls nicht Enter kommt muss der Text gespeichert werden in dem inText Array
        { if(isprint(incomingByte))
          { if(chr_cnt<(MAXBUFFER-2))
              serial_in_buff[chr_cnt++] = incomingByte;
            else
            { Serial.println(F("serBUF ov-> DEL"));
              memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes
              memset(&serial_in_command[0], 0, sizeof(serial_in_command)); // 30.554 Bytes
//              *serial_in_command=0;
              chr_cnt=0;
            } // if(chr_cnt<(MAXBUFFER-1))
          } // if(isprint(incomingByte))
        } // if(incomingByte != 13)
        else // Wenn das Enter ankommt
        { serial_in_buff[chr_cnt] = 0;
          chr_cnt = 0;
          strcpy(serial_in_command, serial_in_buff);
          memset(&serial_in_buff[0], 0, sizeof(serial_in_buff)); // 30.554 Bytes

          if(strlen(serial_in_command))
          { Serial.println(F("")); Serial.print(serial_in_command);  Serial.println(F(" -> erkannt")); 
                  
            if( !strcmp(serial_in_command, "help") || ( !strcmp(serial_in_command, "?") && strlen(serial_in_command)==1 ) )
            { // help screen
              Serial.println(F("\ncommands: \n"));
          
              Serial.println(F("hell, hellp, hellm, hellxx(0-10)"));
              Serial.println(F("con, conp, conm, conxx(55-75)"));
              Serial.println(F("date, dateJJJJ/MO/TA"));
              Serial.println(F("time, timeHH:MM:SS"));
        
              Serial.println(F("up, up?, up07:30"));
              Serial.println(F("down"));
          
              Serial.println(F("stat"));
              Serial.println(F("fstat"));
              Serial.println(F("i2ceep"));
        
              Serial.println(F("reset"));
              Serial.println(F(""));
              memset(&serial_in_command[0], 0, sizeof(serial_in_command));
            }
        
            else if( strstr(serial_in_command, "hell") )
            { if( !strcmp(serial_in_command, "hellp") )
                backlight_p();
              else if( !strcmp(serial_in_command, "hellm") )
                backlight_m();
              else if( !strncmp(serial_in_command, "hell", 4) && strlen(serial_in_command)>4 && strlen(serial_in_command)<7 )
              { // "hell??"
                uint8_t tmp_hell = atoi( (char *)serial_in_command + 4);
                memset(&serial_in_command[0], 0, sizeof(serial_in_command));
                if( tmp_hell>=MIN_BL && tmp_hell<=MAX_BL )
                {  MY_EEP_VAR.backlicht = tmp_hell;
                   analogWrite(NOK_BL, pgm_read_byte(&pwmtable_11C[MY_EEP_VAR.backlicht])); 
                   con_hell_stat(true);  
                }
                else
                { sprintf_P(s_out_str, PSTR("hellxx (%d)-(%d)"), MIN_BL, MAX_BL); Serial.println(s_out_str); // 30.608 Bytes
                }
              } // if( !strcmp(serial_in_command, "hell??") )
              memset(&serial_in_command[0], 0, sizeof(serial_in_command));
            } // if( !strcmp(serial_in_command, "hell") )