STM32Cubeide strstr

[Sascha F. (sascha_focus)]

Hi,

versuche mich gerade , ein ESP8266 per UART anzubinden. Der Uart läuft 
im Interrupt und füllt auch das Array. Nun will ich im Arry auf Strings 
vergleichen:

char RxBuffer[32768]={0,};
uint16_t RxBufferIndex=0;

bool Wifi_WaitForString(uint32_t TimeOut_ms,uint8_t *result,uint8_t CountOfParameter,...)
{
  /*
   * It uses the CountOfParameter and the Parameters after that to compare with the
   * information that it was received in the UART RX. If the parameter is in the
   * received string the functions return a true value and the position of the
   * parameter (according to the position in the function)
   *
   * Ex:
   * Wifi_WaitForString(_WIFI_WAIT_TIME_LOW,&result,2,"OK","ERROR")
   *
   * If the ESP8266 return a AT+OK after the last command, the function is going to
   * return a true value and the result number would be 1.
   */

  if(result == NULL)
    return false;
  if(CountOfParameter == 0)
    return false;

  *result=0;

  va_list tag;
    va_start (tag,CountOfParameter);
    char *arg[CountOfParameter];
    for(uint8_t i=0; i<CountOfParameter ; i++)
      arg[i] = va_arg (tag, char *);
  va_end (tag);

  for(uint32_t t=0 ; t<TimeOut_ms ; t++)
  {
    delay_ms(1);
    for(uint8_t  mx=0 ; mx<CountOfParameter ; mx++)
    {
      if(strstr((char*)RxBuffer,arg[mx])!=NULL)
      {
        *result = mx+1;
        return true;
      }
    }
  }
  // timeout
  return false;

}

Jedoch läuft die Funktion immer in den Timeout, obwohl der gesuchte 
String im Array liegt.

Hat jemand eine Idee, woran es scheitert?

Gruß Sascha

[K. H. (hegy)]

Was mir dazu bisher als Fehlerquellen einfällt:

(1) strstr() checkt auch auf Groß-/Kleinschreibung, ok != OK

(2) das durchchecken des Strings dauert länger als man denkt (Timeout)

(3) delay_ms() ist aktives warten nehme ich mal an, wird in der Zeit 
tatsächlich was in den RxBuffer[] geschrieben (DMA, Interrupt)?

(4) wenn das Programm in der Schleife

for(uint32_t t=0 ; t<TimeOut_ms ; t++)

 steckt, wird CountOfParameter nicht geändert.

Ich kenne den ESP nicht aber ich gehe mal davon aus, dass die CPU den 
Wert von CountOfParameter bzw. den Inhalt von RxBuffer[] nur dann 
ändert, wenn die CPU das auch darf, also die for-Schleife auch mal 
verlässt und andere Dinge macht. Entweder ist da eine 2. CPU noch aktiv 
(Shared Memory u. dgl.) oder aber durch Interrupts werden die Inhalte 
geändert.

Zu Punkt (1): Aus der man-Page von strstr()

strstr(const char *haystack, const char *needle);

The strcasestr() function is like strstr(), but ignores the case of both 
arguments.

char *strcasestr(const char *haystack, const char *needle);

[Rahul D. (rahul)]

Sascha F. schrieb:
> Hat jemand eine Idee, woran es scheitert?

Poste mal bitte mehr Code, so dass man den Kram auch selber compilieren 
könnte.
Hast du deine Funktion mal mit konstanten Werten ausprobiert?
z.B. strstr("ABC", "ABCDEF")

Lass dir doch mal deine args ausgeben.
Groß- und Kleinschreibung hatte Hegy ja schon angesprochen.

[Εrnst B. (ernst)]

Sascha F. schrieb:
> obwohl der gesuchte
> String im Array liegt.

Vorsicht, demnächst hast du evtl. das umgekehrte Problem, die Funktion 
wird immer Strings finden, die garnicht mehr im buffer vorhanden sind.

Problem: strstr (und andere str*-Funktionen) erwarten Null-Terminierte 
Strings.
Wenn deine UART-Receive-ISR das nicht sicherstellt, solltest du nach 
deinem delay_ms(1) ein
RxBuffer[RxBufferIndex]='\0'; einfügen, und für den Rest der Schleife 
die Interrupts sperren...
Very ugly, I know.

Ansonsten schaut das ganze Konzept schon sehr verkorkst aus

[K. H. (hegy)]

Rahul D. schrieb:
> Poste mal bitte mehr Code, so dass man den Kram auch selber compilieren
> könnte.

Ist zwar für "auf'm PC" aber geht, damit habe ich gestern mal 
rumgespielt:
str.c:

#include <stdio.h>
#include <string.h> 
#include <stdint.h>
#include <stdbool.h>
#include <stdarg.h>

char RxBuffer[32768]={0,};
uint16_t RxBufferIndex=0;

void init(void)
{
  sprintf(RxBuffer, "_WIFI_WAIT_TIME_LOW,&result,2,PK,ERRORItusestheCountOfParameterandtheParametersafterthatcomparewiththeinformationthatitwasreceivedintheUARTRX.IftheparameterisinthereceivedstringthefunctionsreturnatruevalueandthepositionOKftheparameter(accordingtothepositioninthefunction");
}

void delay_ms(uint32_t cnt)
{
  for(uint32_t i = 0; i < cnt; i++)
    asm ( "NOP" );
}

bool Wifi_WaitForString(uint32_t TimeOut_ms,uint8_t *result,uint8_t CountOfParameter,...)
{
  /*
   * It uses the CountOfParameter and the Parameters after that to compare with the
   * information that it was received in the UART RX. If the parameter is in the
   * received string the functions return a true value and the position of the
   * parameter (according to the position in the function)
   *
   * Ex:
   * Wifi_WaitForString(_WIFI_WAIT_TIME_LOW,&result,2,"OK","ERROR")
   *
   * If the ESP8266 return a AT+OK after the last command, the function is going to
   * return a true value and the result number would be 1.
   */

  uint32_t cnt = 0;

  if(result == NULL)
    return false;

  if(CountOfParameter == 0)
    return false;

  *result=0;

  va_list tag;
    va_start (tag,CountOfParameter);
    char *arg[CountOfParameter];

    for(uint8_t i=0; i<CountOfParameter ; i++)
    {
      arg[i] = va_arg (tag, char *);
      cnt = i;
    }
    printf("va_arg: i = %i\n", cnt);
  va_end (tag);

  for(uint32_t j = 0; j < cnt; j++)
  { 
    printf("arg[%i] = %s\n", j, arg[j]);
  }

  for(uint32_t t=0 ; t<TimeOut_ms ; t++)
  {
    delay_ms(1);
    for(uint8_t  mx=0 ; mx<CountOfParameter ; mx++)
    {
      printf("arg[mx] = %s, mx = %i\n", arg[mx], mx);
      if(strstr((char*)RxBuffer, arg[mx]) != NULL)
      {
        *result = mx+1;
        printf("result (%s) = %s @%i\n", RxBuffer, arg[mx], mx);
        // return true;
      }
    }
  }

  // timeout
  return false;
}

int main(void)
{
  uint8_t result = 0;

  init();
  Wifi_WaitForString(1, &result, 5, "OK", "ERROR", "Fail", "Stop", "Halt");

  printf("result: %i\n", result);
}

Mit
gcc -Wall -O2 -s str.c -o str
compilieren, geht ohne Fehler und Warnungen.
Ich habe ein paar printf()'s eingebaut, wie man sieht und ein paar 
kleine Änderungen.

Vergessen, der Output:

$ ./str
va_arg: i = 4
arg[0] = OK
arg[1] = ERROR
arg[2] = Fail
arg[3] = Stop
arg[mx] = OK, mx = 0
result (_WIFI_WAIT_TIME_LOW,&result,2,PK,ERRORItusestheCountOfParameterandtheParametersafterthatcomparewiththeinformationthatitwasreceivedintheUARTRX.IftheparameterisinthereceivedstringthefunctionsreturnatruevalueandthepositionOKftheparameter(accordingtothepositioninthefunction) = OK @0
arg[mx] = ERROR, mx = 1
result (_WIFI_WAIT_TIME_LOW,&result,2,PK,ERRORItusestheCountOfParameterandtheParametersafterthatcomparewiththeinformationthatitwasreceivedintheUARTRX.IftheparameterisinthereceivedstringthefunctionsreturnatruevalueandthepositionOKftheparameter(accordingtothepositioninthefunction) = ERROR @1
arg[mx] = Fail, mx = 2
arg[mx] = Stop, mx = 3
arg[mx] = Halt, mx = 4
result: 2

[Wastl (hartundweichware)]

K. H. schrieb:
> void delay_ms(uint32_t cnt)
> {
>   for(uint32_t i = 0; i < cnt; i++)
>     asm ( "NOP" );
> }

Kein Wunder dass man damit in ein Timeout fällt.

[K. H. (hegy)]

Wastl schrieb:
> Kein Wunder dass man damit in ein Timeout fällt.

Ich bin davon ausgegangen, dass die delay_ms() Funktion sowas in der Art 
ist und deswegen habe ich mir mal eben schnell so eine 
aktives-Warten-Funktion gebaut.

Bei mir sieht z. B. die HAL-Delay() Funktion so aus:

void HAL_Delay(uint32_t Delay) // Delay = ms
{
    if(Delay == 0)
        return;

    if(Delay > HAL_MAX_DELAY)
        return;

    uint32_t tickstart = HAL_GetTick();

    while((HAL_GetTick() - tickstart) < Delay);
}