strstr() gibt keinen NULL pointer zurück? (atmega 2560)

[Hans L. (haled)]

Hallo zusammen,

ich habe folgendes Problem:
Ich sende einen String den ich aus einer Datei lese per UART an den MCU 
(atmega 2560). Dort will ich aus diesem mit strstr() X und Y Koordinaten 
extrahieren.
Leider bleibt der Code in der While-Schleife hängen da scheinbar 
strstr() nie einen NULL Pointer zurück gibt. Ist der NULL Character '\0' 
zur Beendung des Strings falsch gesetzt?
Ich kann meinen Fehler leider nicht finden. Vielleicht könnt ihr mir 
helfen!?

Ich sende den String: "G01 X69.204775 Y23.337389 Z-0.100000 G01 
X80.964849 Y21.666507 Z-0.100000 G00 Z0.100000 (End cutting path id: 
path4285"

Zurück bekomme ich am Serial Port:

G01 X69.204775 Y23.337389 Z-0.100000 G01 X80.964849 Y21.666507 Z-0.100000 G00 Z0.100000 (dppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppppp

 usw.

Mein Code sieht folgendermaßen aus ( zu beachten USART_Transmit('p'); um 
das while loop zu zeigen):

void USART_Init(unsigned int ubrr); 
void USART_Transmit(unsigned char data); 
unsigned char USART_Receive( void );
char uart_char;
char uart_string[100] = {""};

int main(void) 
{ 
  int char_counter = 0;
  USART_Init(MYUBRR); 
  while(uart_char != '('){
    uart_char = USART_Receive();
    uart_string[char_counter] = uart_char;
    char_counter++;
  }
  uart_string[char_counter] = '\0';
  
  for(int i = 0;i<sizeof(uart_string);i++){
    USART_Transmit(uart_string[i]);
  }

  char *hier;
  char x_values[50][7];
  char y_values[50][7];
  int number_of_coordinates = 0;
  USART_Transmit(sizeof(uart_string));
  while( (hier = strstr(uart_string, "G01 X")) != NULL){
    strncpy(x_values[0],hier+5,6);
    strncpy(y_values[0],hier+5+11,6);     
    number_of_coordinates++;
    USART_Transmit('p');
  }
  USART_Transmit('r');
  uint8_t coordinates [number_of_coordinates][2];
  for(int i=0;i<number_of_coordinates;i++){
    coordinates[i][0] = (int) atof(x_values[i]);
    coordinates[i][1] = (int) atof(y_values[i]);
  }
}

[Stefan F. (Gast)]

Hans L. schrieb:

while( (hier = strstr(uart_string, "G01 X")) != NULL) {
    strncpy(x_values[0],hier+5,6);
    strncpy(y_values[0],hier+5+11,6);
    number_of_coordinates++;
    USART_Transmit('p');
}

Da du innerhalb der while Schleife den gefundenen String nicht aus 
uart_string entfernst, findest du ihn immer wieder erneut.

[Lutz B. (lutzbroszio)]

strstr liefert nur zurück ob der gesuchte String enthalten ist. Der 
String ändert sich auch nicht, deswegen hängst du in deiner while 
Schleife.

Auch solltest du überprüfen, ob der empfangene String größer als dein 
Buffer ist.

[GEKU (Gast)]

Hans L. schrieb:
> while( (hier = strstr(uart_string, "G01 X")) != NULL){
>     strncpy(x_values[0],hier+5,6);
>     strncpy(y_values[0],hier+5+11,6);
>     number_of_coordinates++;
>     USART_Transmit('p');
>   }
Suche wird immer an der gleichen Stelle fortgesetzt!

char *pNext;   // !!!!

int main(void) 
{ 
  int char_counter = 0;
  USART_Init(MYUBRR); 
  while(uart_char != '('){
    uart_char = USART_Receive();
    uart_string[char_counter] = uart_char;
    char_counter++;
  }
  uart_string[char_counter] = '\0';
  
  for(int i = 0;i<sizeof(uart_string);i++){
    USART_Transmit(uart_string[i]);
  }

  char *hier;  
  char x_values[50][7];
  char y_values[50][7];
  int number_of_coordinates = 0;
  USART_Transmit(sizeof(uart_string));

  pNext=uart_string; //!!!!

  while( (hier = strstr(pNext, "G01 X")) != NULL){ //!!!!
    strncpy(x_values[0],hier+5,6);
    strncpy(y_values[0],hier+5+11,6);     
    number_of_coordinates++;
    USART_Transmit('p');
    pNext=hier; // !!!! hier wird bei der Suche weiter gesprungen
  }
  USART_Transmit('r');
  uint8_t coordinates [number_of_coordinates][2];
  for(int i=0;i<number_of_coordinates;i++){
    coordinates[i][0] = (int) atof(x_values[i]);
    coordinates[i][1] = (int) atof(y_values[i]);
  }
}

So sollte es gehen.

[GEKU (Gast)]

GEKU schrieb:
> pNext=hier; // !!!! hier wird bei der Suche weiter gesprungen

Blödsinn,

natürlich

pNext=hier+1;

[Hans L. (haled)]

Vielen Dank!!! :-)
Jetzt macht es Sinn!!

habe es jetzt so umgesetzt und es funktioniert:

  while( (hier = strstr(uart_string, "G01 X")) != NULL){
    strncpy(x_values[number_of_coordinates],hier+5,6);
    strncpy(y_values[number_of_coordinates],hier+5+11,6);
    strcpy(uart_string,hier+5);     
    number_of_coordinates++;
  }

[Stefan F. (Gast)]

Der Kopiervorgang ist allerdings wesentlich teurer, als den Zeiger zu 
versetzen.

[GEKU (Gast)]

Stefanus F. schrieb:
> Der Kopiervorgang ist allerdings wesentlich teurer, als den Zeiger zu
> versetzen.

Das ist der Grund warum C schneller ist als so mach andere Sprache ist. 
Zeiger machen es möglich. Aber es ist gefährlich wenn man nicht weiß was 
man damit anstellt.

[Dirk B. (dirkb2)]

Hans L. schrieb:
> strncpy(x_values[0],hier+5,6);

Das funktioniert nicht so, wie du dir das vorstellst.

Wenn in den 6 Zeichen keine '\0' gefunden wird, wird auch keine kopiert.
Der String in x_Values ist nicht terminiert.

Warum überhaupt der Umweg über das 2D-char-Array.
atof hört da auf, wo es keine gültig Zahl erkennt.

Warum überhaupt atof, wenn du eigentlich atoi möchtest.
besser noch strtoul.

[GEKU (Gast)]

Es geht kürzer und klarer.
Das Einfügen der Z-Koordinaten sind jetzt ein Kinderspiel.

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

char uart_string[]="G01 X69.204775 Y23.337389 Z-0.100000 G01 X80.964849 Y21.666507 Z-0.100000 G00 Z0.100000";

int main(void)
{
    char *px;
    float coordinates[10][2];

    int number_of_coordinates = -1;

    px=uart_string;

    memset(coordinates,0,sizeof(coordinates));

    while (*px)
    {
        switch (*px)
        {
            case 'G':
                number_of_coordinates++;
                break;

            case 'X':
                px++;
                coordinates[number_of_coordinates][0]=atof(px);
                break;

            case 'Y':
                px++;
                coordinates[number_of_coordinates][1]=atof(px);
                break;

            default:
                break;
        }
        px++;
    }

    for (number_of_coordinates=0;number_of_coordinates<10;number_of_coordinates++)
    {
        printf("%d\tx=%f\t\ty=%f\r\n",number_of_coordinates,coordinates[number_of_coordinates][0],coordinates[number_of_coordinates][1]);
    }
}

Vorteil :

-weniger Variable
-weniger Code
-vermutlich wesentlich schneller
-leichtere Ausbaufähigkeit

Auch für Prozessoren mit wenig SRAM geeignet, da strstr() ein 
Speicherfresser ist.

[GEKU (Gast)]

Beispiel mit Z-Koordinate

[GEKU (Gast)]

GEKU schrieb:
> while (*px)

man könnte auch mit "while (uart_char)" direkt die Zeichen vom UART 
einlesen und im SWITCH die Abbruchbedingung exekutieren.

[GEKU (Gast)]

GEKU schrieb:
> man könnte auch mit "while (uart_char)" direkt die Zeichen vom UART
> einlesen und im SWITCH die Abbruchbedingung exekutieren.

Vergessen , geht nicht so einfach, da mehrere Zeichen für FLOAT 
Variable gelesen werden müssen

[Hans L. (haled)]

Hallo zusammen,

vielen Dank, dass ihr euch so viel Zeit genommen habt und meine Frage so 
detailliert beantwortet habt!
Ihr habt mir sehr geholfen und ich konnte auch viel dabei lernen!
Ich habe es jetzt so umgesetzt wie oben vorgeschlagen.

Echt klasse!!!