C167 reading/scanning input from GSM module from RS232

Look up strcmp and associated functions in the Standard 'C' library.

Look up strcmp and associated functions in the Standard 'C' library.

I can get string by using gets() but can only compare two strings that are entered but not read.

Any ideas to how to get round this?

Do I have to place read string into memory etc?

"I can get string by using gets() but can only compare two strings that are entered but not read."

I'm afraid I don't really understand your question. At a guess the GPS outputs a variety of (NMEA0183?) strings and you are trying to identify the one of interest before sucking the data out of it.

"Do I have to place read string into memory etc?"

Yes. It is probably easier to write your own routine to read in the string. That way you can detect the start and end characters to ensure that you capture one complete string with everything in the right place. You should then be able to use sscanf() to extract the data.

Stefan

An example of the code I was trying to use is belo. It does not work. I will try sscanf now. Thanks.


#include <stdio.h> /* standard I/O .h-file */
#include <reg167.h> /* special function register 80C167 */
#include <string.h>
{
char arr[50];
gets(arr);

printf("\nInput read into array was:\n"); //* just for confirmation*//
puts(arr);
char *string[1] = {"OK"} ; //* string 1 = OK (text)
char *string[2] = gets(arr);
int strcmp(string[1], char* arr);
}
{}

{
}
}

please remember to use the < pre > and < /pre > tags for code - as it says in the instructions when you make a post!

You are confusing your arrays and pointers - you need to re-read the section on strings in your 'C' textbook.

The code you've shown won't compile, not least because you have defined the symbol 'string' twice:

char *string[1] = {"OK"} ; //* string 1 = OK (text)

char *string[2] = gets(arr);

Note also that your definitions of 'string' come after executable code - you can't do that in 'C'.

You can do it in C++, but not in 'C'.

Be sure that you're rading a 'C' textbook, not C++!

Interfacing to GSM can be a pain. You may find the code below useful - I certainly did - it is a string compare function with a limited wildcard facility.

/*****************************************************************************
 *
 *  String Compare
 *
 *  Trigger:    Local call.
 *
 *  Input:      Pointers to the 'expected' and 'search' strings.
 *
 *  Output:     Returns TRUE to indicate a match and FALSE otherwise.
 *
 *  Function:   Compares two strings and returns TRUE if identical.
 *
 *  Notes:      Allows the use of character (?) and string (~) wildcards in
 *              the specification of the expected string.
 *
 *              THE ORDER OF EXPECTED AND ACTUAL POINTERS IS IMPORTANT
 *              WHEN THE WILDCARDS ARE USED.
 *
 *              THE EXPECTED STRING MUST BE IN CODE MEMORY AND THE
 *              ACTUAL STRING MUST BE IN XDATA.
 *
 *****************************************************************************/

bit user_strcmp(unsigned char code *er, unsigned char xdata *ar) large
{                                                   // ar = actual_string
                                                    // er = expected_string
    bit    match = TRUE;                            //
                                                    //
    do                                              // String compare loop
    {                                               //
        if( *er == '?' )                            // If a character wildcard is
        {                                           // in the expected string:
            er++;                                   // don't test this actual char
        }                                           //
        else if( *er == '~' )                       // If a string wildcard:
        {                                           //
            er++;                                   // Start the inner loop
                                                    // looking for the next
                                                    // char after the ~.
            while( (*ar != *er ) && ( *ar != '\0')) // Inner loop searches
            {                                       // through the actual string
                                                    // until either a match with
                                                    // the char after the expected
                ar++;                               // or the end of the actual
            }                                       // string.
                                                    //
                                                    // If the loop terminated due
                                                    // to the actual \0 char
            if( *er != *ar )                        // but we were expecting
            {                                       // something else
                match = FALSE;                      // we need to test again to
            }                                       // catch this condition.
            if( *er != '\0' )                       //
            {                                       //
                er++;                               //
            }                                       //
        }                                           //
        else                                        // Normal test (No wildcard)
        {                                           //
            if( *er != *ar )                        //
            {                                       //
                match = FALSE;                      //
            }                                       //
            if( *er != '\0' )                       //
            {                                       //
                er++;                               //
            }                                       //
        }                                           //
    }                                               //
    while( ( *ar++ != '\0') && (match) );           //
                                                    //
    if( *er != '\0' )                               //
    {                                               //
        match = FALSE;                              //
    }                                               //
                                                    //
    return( match );                                //
}                                                   //

"You may find the code below useful ...

Input:      Pointers to the 'expected' and 'search' strings."