STM32F4 Zeichenfolge "herausfischen"

[Christoph H. (christoph_b)]

Hallo

Nach längerer Zeit habe ich wieder einmal eine Frage in C ;-)
Da ich mich sonst seit ca 3 Jahren nur mit C# beschäftige fällt mir das 
progen in C extrem schwer

Nun meine Frage

Ich sende per UART an ein Bluethooth device folgende Zeichenfolge
INQUIRY 1

zurück bekomme ich z.B

INQUIRY 1
INQUIRY_PARTIAL 10:68:3f:24:6e:e2 5a020c "" -68
INQUIRY_PARTIAL 08:d4:2b:1e:40:40 1a010c "" -66
INQUIRY 2
INQUIRY 10:68:3f:24:6e:e2 5a020c
INQUIRY 08:d4:2b:1e:40:40 1a010c

jetzt brauche ich folgende Teile ( MAC Adresse) am besten in einem Array
10:68:3f:24:6e:e2,-68
08:d4:2b:1e:40:40,-66

Leider komme ich nicht dahinter wie ich das am besten auf einem STM32F4 
löse. Ich sollte die Werte im Ram zwischenspeichern. Maximal kommen so 
ca 200 Werte zusammen.

Dachte an ein Zweidimensionale char Array.

Vieleicht kann mir jemand auf die Sprünge helfen.

Gruß Christoph

[Martin T. (mthomas) (Moderator)]

Folgt auf den Empfang von INQUIRY 2 immer die Liste der Adressen mit 
INQUIRY-Prefix? Was folgt auf die Adress-Liste? Leerzeile, Pause oder 
sind es immer zwei Zeilen? Mit welchen/welchen Zeilen sind die Zeilen 
abgeschlossen (CR, LF, CRLF)? Es bietet sich eine Zeilenweise 
Verarbeitung in einem Zustandsautomaten an, Pseudocode grob vereinfacht 
(ohne Timout-, Pufferüberlauf- und nur wenig Fehlerbehandlung):

rec = ""
state = 0
done = false
error = false

while !done
 if uart_hat_zeichen_empfangen then
  if empfangenes_zeichen = zeilenende then
    switch (state)
    case 0:
      if rec == "INQUIRY 2" then
        state = 1
        nmacs = 0
      endif
    case 1:
      if left(rec) == "INQUIRY" then
       mac[nmacs] = right(rec)
       nmacs++
       if nmacs = 2 then 
         done = true
       endif
      elseif
        error = true  // Fehler, INQUIRY erwartet, aber nicht erhalten
        done = true
      endif
      rec = ""
    endswitch
  else
    rec += empfangenes_zeichen
  endif
endwhile

Falls abweichende Antworten möglich sind, kann man diese in dem 
Zustandsautomaten mittels weiterer Fälle im "switch" unterbringen.

[Christoph H. (christoph_b)]

hallo

auf INQUIRY 1

folgt immer nochmals INQUIRY 1 als bestätigung

Danach kommen die Zeilen die ich benötige. Anzahl ist unbekannt und 
variert.
z.b
INQUIRY_PARTIAL 10:68:3f:24:6e:e2 5a020c "" -68
INQUIRY_PARTIAL 08:d4:2b:1e:40:40 1a010c "" -66
INQUIRY_PARTIAL 04:as:8d:1a:42:20 1a010c "" -51
....
Als nächstes kommt wieder der Befehl INQUIRY mit der Anzahl der Zeilen 
hier z.b 3 also
INQUIRY 3

der Rest kann weg vergessen werden.

Die Zeilen werden mit <\r><\n> abgeschlossen

[Christoph H. (christoph_b)]

So habe es so weit hinbekommen

#include "string.h"
#include "stdlib.h"
#include "main.h"
#include "stm32_ub_udp_server.h"
#include "stm32_ub_led.h"
#include "stm32_ub_uart.h"
#include "stm32_ub_tim5.h"

int i=0;
char delimiter[]=" """;
char *ptr;
char output[30];

char output_array[10][25];
int array_help;
int e;
int d;
int f;

void UB_TIMER5_ISR_CallBack(void)
{
  i=0;
  UB_Led_Toggle(LED_GREEN);
  //UB_Uart_SendString(COM3,"AT",CRLF);
  UB_Uart_SendString(COM3,"INQUIRY 2",CRLF);
}

int main(void)
{
  int array_count=1;
  //char mac[20][20]={"10:68:3f:24:6e:d2","08:d4:2b:1e:40:05"};
  char mac[10][19];
  char t[10];

  UDP_INIT_STATUS_t init_check;
  UDP_RECEIVE_t rec_check;
  char rx_buf[UDP_RX_BUFFER_SIZE];

  char buf[RX_BUF_SIZE]; // puffer fuer Datenempfang UART
  UART_RXSTATUS_t check;

  SystemInit(); // Quarz Einstellungen aktivieren

  // LEDs initialisieren
  UB_Led_Init();
  UB_Uart_Init();

  // UDP-Server initialisieren
  init_check=UB_UDP_Server_Init();
  if(init_check==UDP_INIT_OK) {
    // wenn initialisierung ok
    UB_Led_On(LED_GREEN);
    // Server starten
    if(UB_UDP_Server_Connect()==UDP_CONNECT_OK) {
      // wenn der Server läuft
      // einmal einen Text per UDP senden
      UB_UDP_Server_SendString("UDP Server ok");
    }
  }
  else {
    // bei einem Fehler
    UB_Led_On(LED_RED);
  }

  UB_TIMER5_Init(8399,39996); // alle 4 sec
  UB_TIMER5_Start();

  while(1)
  {
    // UDP-Server zyklisch aufrufen
    // und check ob Daten empfangen wurden
    rec_check=UB_UDP_Server_Do(rx_buf);
    if(rec_check==UDP_SERVER_OFFLINE) {
      // UDP-Server ist Offline
      UB_Led_Off(LED_BLUE);
    }
    else {
      // UDP-Server ist Online
      //UB_Led_On(LED_BLUE);
      if(rec_check==UDP_RECEIVE_READY)
      {
        if(strcmp(rx_buf, "OK") == 0)
        {
          UB_Led_Toggle(LED_BLUE);
          for(d=0;d<=2;d++)
          {
            UB_UDP_Server_SendString(output_array[d]);
            UB_Led_Toggle(LED_BLUE);
          }
          //if(UB_UDP_Server_SendString(mac[1])==ERROR)
          //{
          //UB_Led_Toggle(LED_BLUE);
          //}
          }

      }

      check=UB_Uart_ReceiveString(COM3,buf);
      if(check==RX_READY) {
        UB_Led_Toggle(LED_RED);
        //i++;
        if(strlen(buf)>40)
        {
          //if(strncmp(buf,"INQUIRY_PARTIAL",15))
          //if(strncmp(buf,"INQUIRY 1",9))
          //{
          ptr=strtok(buf,delimiter);
          while(ptr!=NULL)
          {
            i++;
            sprintf(mac[i],"%s\n",ptr);
            //sprintf(mac[1],"%s\n",ptr);
            ptr=strtok(NULL,delimiter);
          }
          //strncpy(mac[0], buf, 35);
          strcpy(output,mac[2]);
          strncat(output,mac[5],30);
          //UB_UDP_Server_SendString(output);
          for (e=0;e<sizeof(output_array);e++)
          {
            if(strncmp(output,output_array[e],10)!=0)
            {
              UB_Led_Toggle(LED_BLUE);
              strcpy(output_array[array_count],output);

              array_count++;
            }
          }
        }

      }
    }
  }
}

im Array "output" finde ich folgenden Zeichenfolge "b4:b6:76:ea:f7:80
-62"

die letzen 3 zeichen gibt die Signalstärke an.

Nun wollte ich die Zeichenfolge in ein Array kopieren sofern sie noch 
nicht in im Array enthalten ist.
Leider hängt das Programm sich dabei auf.

Hier der auschnitt wo ich nicht weiterkomme

          for (e=0;e<sizeof(output_array);e++)
          {
            if(strncmp(output,output_array[e],10)!=0)
            {
              UB_Led_Toggle(LED_BLUE);
              strcpy(output_array[array_count],output);

              array_count++;
            }
          }

[jgdo (Gast)]

Gibt es einen Grund dafür, warum du kein C++ nutzen möchtest? Der 
STM32F4 ist ja nicht gerade ein Controller, bei dem es auf jedes Byte 
ankommt.
Dann könntest du Regexe verwenden und das ganze wäre kein Problem mehr.

[Christoph H. (christoph_b)]

ich kenn mich mit C++ gar nicht aus. Leider. ,-)

Habe es aber irgendwie mit C nun hinbekommen. Es geht ja nunr um einen 
Test einer Hardware.