File content as of revision 4:38acbd6f9d9e:

/* Copyright (c) 2015 ARM Limited
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * @section DESCRIPTION
 *
 * Parser for the AT command syntax
 *
 */
 
#include "mbed.h"
#include <stdarg.h>

#include "BufferedSerial.h"

 
/**
* The ATParser class wraps information about the serial in use
*/
class ATParser {
private:
    // Serial information
    BufferedSerial *_serial;
    int _buffer_size;
    char *_buffer;
    int _timeout;
    
    // Parsing information
    const char *_delimiter;
    int _delim_size;    
    
    // Helper methods for reading/writing lines with 
    // timeout and buffer limitations
    bool _putline(const char *line);
    bool _getline(char *line, int size);

public:
    /**
    * Constructor
    *
    * @param serial serial interface to use for AT commands
    * @param buffer_size size of internal buffer for transaction
    * @param timeout timeout of the connection
    * @param echo flag to indicate if an echo of sent characters should be expected
    * @param delimiter string of characters to use as line delimiters
    */
    ATParser(BufferedSerial *serial, int buffer_size = 256, int timeout = 3000,
             const char *delimiter = "\r\n") :
            _serial(serial),
            _buffer_size(buffer_size) {
        _buffer = new char[buffer_size];
        setTimeout(timeout);
        setDelimiter(delimiter);
    }
    
    /**
    * Destructor
    */
    ~ATParser() {
        delete [] _buffer;
    }
    
    /**
    * Allows timeout to be changed between commands
    *
    * @param timeout timeout of the connection
    */
    void setTimeout(int timeout) {
        _timeout = timeout;
    }
    
    /**
    * Sets string of characters to use as line delimiters
    *
    * @param delimiter string of characters to use as line delimiters
    */
    void setDelimiter(const char *delimiter) {
        _delimiter = delimiter;
        _delim_size = strlen(delimiter);
    }
            
    /**
    * Issue AT commands
    *
    * Sends formatted command and waits for formatted response.
    * Any recieved data that does not match the specified response 
    * is ignored until the timeout has passed.
    *
    * Both the command and response use format strings that are internally
    * passed to printf and scanf respectively.
    * @see printf
    * @see scanf
    *
    * Commands are expected to be formatted with specified delimiters.
    * Sent commands are appended with the delimiter, and responses are
    * seperated by delimiters before attempting to parse.
    *
    * Here are some examples:
    * @code
    * at.command("AT", "OK");
    * at.command("AT+CWMODE=%d", "OK", 3);
    * at.command("AT+CWMODE?", "+CWMODE:%d\r\nOK", &result);
    * @endcode
    *
    * @param command printf-like format string of command to send
    * @param response scanf-like format string of response to parse
    * @param ... all printf-like arguments to insert into command followed by 
    *            all scanf-like pointers to destinations for response values
    * @return true only if response is successfully matched
    */
    bool command(const char *command, const char *response, ...);
    
    /** 
     * Write a single byte to the underlying stream
     *
     * @param c The byte to write
     * @return The byte that was written or -1 during a timeout
     */
    int putc(char c);
    
    /** 
     * Get a single byte from the underlying stream
     *
     * @return The byte that was read or -1 during a timeout
     */
    int getc();
    
    /**
     * Flushes the underlying stream
     */
    void flush();
};