Wie erstellen Sie AUF Befehle-Parser in C, um die eingehende Zeichenfolge aus USART1?

Ich möchte den string von USART1 von STM32VLDiscovery (STM32F100X4) und schreiben Sie einen AT-Befehl-Parser, der aus der Zeichenfolge empfangen von USART1.

Unten sind das Konzept, das ich entwickelt habe, aber ich bin mir nicht sicher, ob es richtig ist oder nicht.

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

#include "dosomethinga.h"

void dosomethingB();
void GET_AT_COMMAND(char*);
void takecommand(char *, char *);
int quit;


int main()
{   char buff[15];
    char command = '\0';
    quit = 0;

    while(!quit)
    {
        printf("Enter your command: ");
        scanf("%s", &buff);

        if (buff[0] == 'A' && buff[1] == 'T' && buff[2] == '+')
        {
            GET_AT_COMMAND(buff);
        }

    }
}

void dosomethingB()
{
    printf("dosomethingB called \n");
}

void GET_AT_COMMAND(char *text)
{
    int command;
    char temp[10] = "";

    /*if(text[3] == 'A')
          command = 1;

    else if(text[3] == 'B')
        command = 2;

    else if(text[3] == 'Z')
        command = 3;
    */

    takecommand(text,temp);

    if (strcmp(temp, "CALLA") == 0)
        command = 1;

    if (strcmp(temp, "CALLB") == 0)
        command = 2;

    if (strcmp(temp, "Z") == 0)
        command = 3;

    switch(command)
    {
        case 1:
            dosomethingA();
            break;

        case 2:
            printf("herehere.... \n");
            dosomethingB();
            break;

        case 3:
            printf("Exiting program.... \n");
            quit = 1;
            break;


        default:
            printf("Nothing to do here \n");
     }
}

void takecommand(char *mycmd, char *hold)
{
    int i;
    for(i = 0; i < 10 ; i++)
    {
         hold[i] = mycmd[i+3];
    }
}

Kann mir jemand erklären, auf die Schritte, die ich tun sollte? Danke.

Ich weiß nicht, etwas über AT-Befehle, aber ich Wette, Sie können sich rasieren, ein paar Zeilen code durch verschieben der case Blöcke von Ihrem switch Anweisung benannte Funktionen und ruft Sie in die if-else block. if(strcmp(temp, "CALLA") == 0) dosomenthingA(); else if(...) dosomethingB(); ....
Vielleicht besser für die code-review ? Sie haben einen Fehler : scanf("%s", &buff) buff ist ein array und kann direkt verwendet werden, und Sie kümmern sollte, Eingangs-Länge : scanf("%.14s", buff). Und takecommand enthält ein Magie 10 ; wenn Sie müssen, ändern Sie die Größe der Befehle, die Sie haben, um es zu beheben in vielen Orten. Und strncpy oder memcpy schon funktioniert es. (nur den ersten Blick-Analyse ...)

InformationsquelleAutor arissajonny | 2014-07-23

  1. 2

    Grundsätzlich sollten Sie warten, eine Aufmerksamkeit "BEI" von der input und ignorieren alles, bevor es.
    Zum Beispiel Eingänge "XYZATZ\r" und "AaatZ\r" sollten beide behandelt, wie ein "ATZ" - Befehl.
    Es kann auch eine sehr kurze pause zwischen 'Ein' und 'T' (und alle anderen chars von Befehlen auch), denn die geben die Befehle.

    Durch den Standardwert alle Befehle end, "\r" - Zeichen.

    Sehen Sie mehr über AT-Befehle von der ITU-T Dokumentation. Zum Beispiel von V. 250 standard.

    Wahrscheinlich gibt es viele alternative Wege zur Implementierung. Die beste alternative sind, hängt von Ihren Bedürfnissen ab. Wenn Sie gehen, um alle AT-Befehle der mobile-terminal, dann sollten Sie verbringen mehr Zeit für den parser. Wenn Sie möchten, machen Sie einige test-Anwendung für das paar Befehle, dann wird Ihre Umsetzung könnte sein einfach wie Ihr zur Verfügung gestellt.

    Beachten Sie, dass der A + T-Zeichen, die beide entweder in der oberen oder unteren Fall (z.B. ATZ, ATz, atZ oder atz sind alle gültig, aber AtZ zum Beispiel nicht).

    InformationsquelleAutor SKi

  2. 1

    Ich entwickelt haben, das AUF-Befehl-parser, könnte diese Referenz verwenden.

    Wenn Sie Daten von UART1 nur diese Methode aufrufen at_wait_msg() zu analysieren, die BEI der Nachricht

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

static const char *AT_HEADER = "AT";
static const char *AT_DEVICE_PROFILE = "DR";
static const char *AT_SET_DEVICE = "SD";

static const char AT_EOF = '\r';

typedef enum {
    DeviceProfile,
    SetDevice,
    Error
} AT_Msg_Type;

typedef struct {
    char header[3];
    char command[3];
    char data[128];
} AT_Msg_Data;

static void at_wait_msg(char text);
static void at_wait_msg_complete(char *text);
static void at_parse_msg(AT_Msg_Data *data);
static AT_Msg_Type at_check_format(AT_Msg_Data *data);

static char _rx_data[512];
static uint16_t _rx_index = 0;

int main()
{
    //example data getting from UART1
    char text[] = "ATDR\rATSD123456abchelloworld\r1123ATssa\r";

    for (int i = 0; i < strlen(text) + 1; i++) {
        //to simulate getting data from UART1 byte per byte
        at_wait_msg(text[i]);
    }

    return 0;
}

static void at_wait_msg(char text)
{
    _rx_data[_rx_index++] = text;

    if (text == AT_EOF) {
        at_wait_msg_complete(_rx_data);

        _rx_index = 0;      
    }
}

static void at_wait_msg_complete(char *text)
{
    AT_Msg_Data data;

    int result = sscanf_s(_rx_data, "%2s%2s%s\r",
        data.header, sizeof(data.header),
        data.command, sizeof(data.command),
        data.data, sizeof(data.data));

    if (result >= 2) {
        at_parse_msg(&data);
    }
}

static void at_parse_msg(AT_Msg_Data *data)
{
    AT_Msg_Type type = at_check_format(data);

    switch (type) {
    case DeviceProfile:
        printf("device profile\r\n");
        break;
    case SetDevice:
        printf("settings %s\r\n", data->data);
        break;
    case Error:
    default:
        printf("Error\r\n");
        break;
    }
}

static AT_Msg_Type at_check_format(AT_Msg_Data *data)
{
    if (strcmp(data->header, AT_HEADER) != 0) {
        return Error;
    }

    if (strcmp(data->command, AT_DEVICE_PROFILE) == 0) {
        return DeviceProfile;
    }

    if (strcmp(data->command, AT_SET_DEVICE) == 0) {
        return SetDevice;
    }

    return Error;
}

    InformationsquelleAutor Tim

Schreibe einen Kommentar