File content as of revision 6:51f1171b5ebc:

/* 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 "ATParser.h"

// This can be defined to assist in debugging
#define AT_ECHO 1


// getc/putc handling with timeouts
int ATParser::putc(char c) {
    Timer timer;
    timer.start();
    
    while (true) {
        if (_serial->writeable())
            return _serial->putc(c);
            
        if (timer.read_ms() > _timeout)
            return -1;
    }
}

int ATParser::getc() {
    Timer timer;
    timer.start();
    
    while (true) {
        if (_serial->readable())
            return _serial->getc();
            
        if (timer.read_ms() > _timeout)
            return -1;
    }
}

void ATParser::flush() {
    while (_serial->readable())
        _serial->getc();
}

// read/write handling with timeouts
int ATParser::write(const char *data, int size) {
    int i;
    
    for (i = 0; i < size; i++) {
        if (putc(data[i]) < 0)
            return i;
    }
    
    return i;
}

int ATParser::read(char *data, int size) {
    int i;
    
    for (i = 0; i < size; i++) {
        int c = getc();
        
        if (c < 0)
            return i;
            
        data[i] = c;
    }
    
    return i;
}


// getline/putline handling with timeouts/bounds checking
bool ATParser::_putline(const char *line) {    
    for (int i = 0; line[i]; i++) {
        if (putc(line[i]) < 0)
            return false;
    }
    
    // Finish with newline
    for (int i = 0; _delimiter[i]; i++) {
        if (putc(_delimiter[i]) < 0)
            return false;
    }
    
#ifdef AT_ECHO
    printf("AT> %s\r\n", line);
#endif
    
    return true;
}

bool ATParser::_getline(char *line, int size) {
    int i = 0;
    
    while (i < size) {
        int c = getc();
        if (c < 0)
            return false;
            
        line[i++] = c;
        
        // Finish when we hit a newline
        if (memcmp(&line[i-_delim_size], _delimiter, _delim_size) == 0) {
            line[i-_delim_size] = 0;
#ifdef AT_ECHO            
            printf("AT< %s\r\n", line);
#endif
            return true;
        }
    }
    
    // Ran out of space
    return false;
}


// Command parsing with line handling
bool ATParser::vsend(const char *command, va_list args) {
    flush();
    
    // Create and send command
    if (vsprintf(_buffer, command, args) < 0)
        return false;
    if (!_putline(_buffer))
        return false;
        
    return true;
}

bool ATParser::vrecv(const char *response, va_list args) {
    // Iterate through each line in the expected response
    while (response[0]) {
        // Since response is const, we need to copy it into our buffer to
        // add the line's null terminator and clobber value matches with asterisks.
        //
        // We just use the beginning of the buffer to avoid unecessary allocations.
        int i = 0;
        int offset = 0;
        
        while (response[i]) {
            if (memcmp(&response[i+1-_delim_size], _delimiter, _delim_size) == 0) {
                i++;
                break;
            } else if (response[i] == '%' && 
                       response[i+1] != '%' && 
                       response[i+1] != '*') {
                _buffer[offset++] = '%';
                _buffer[offset++] = '*';
                i++;
            } else {
                _buffer[offset++] = response[i++];
            }
        }
        
        // Scanf has very poor support for catching errors
        // fortunately, we can abuse the %n specifier to determine
        // if the entire string was matched.
        _buffer[offset++] = '%';
        _buffer[offset++] = 'n';
        _buffer[offset++] = 0;
        
        // To workaround scanf's lack of error reporting, we actually
        // make two passes. One checks the validity with the modified
        // format string that only stores the matched characters (%n). 
        // The other reads in the actual matched values.
        //
        // We keep trying the match until we succeed or some other error
        // derails us.
        while (true) {
            // Recieve response
            if (!_getline(_buffer+offset, _buffer_size-offset))
                return false;
            
            int count = -1;
            sscanf(_buffer+offset, _buffer, &count);
            
            // We only succeed if all characters in the response is matched
            if (count >= 0 && (_buffer+offset)[count] == 0) {
                // Reuse the front end of the buffer
                memcpy(_buffer, response, i);
                _buffer[i] = 0;
                
                // Store the found results
                vsscanf(_buffer+offset, _buffer, args);
                
                // Jump to next line and continue parsing
                response += i;
                break;
            }
        }
    }
    
    return true;
}

bool ATParser::vcommand(const char *command, const char *response, va_list args) {
    if (command) {
        if (!vsend(command, args))
            return false;
    }
    
    if (response) {
        if (!vrecv(response, args))
            return false;
    }
    
    return true;
}

// Mapping to vararg functions
bool ATParser::send(const char *command, ...) {
    va_list args;
    va_start(args, command);
    bool res = vsend(command, args);
    va_end(args);
    return res;
}

bool ATParser::recv(const char *response, ...) {
    va_list args;
    va_start(args, response);
    bool res = vrecv(response, args);
    va_end(args);
    return res;
}

bool ATParser::command(const char *command, const char *response, ...) {
    va_list args;
    va_start(args, response);
    bool res = vcommand(command, response, args);
    va_end(args);
    return res;
}