Diff: UbloxATCellularInterfaceExt.cpp

Revision:

0:0b75e22c9231

Child:

1:26a67ab07275

--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/UbloxATCellularInterfaceExt.cpp	Mon Jun 05 12:58:04 2017 +0000
@@ -0,0 +1,984 @@
+/* Copyright (c) 2017 ublox 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.
+ */
+
+#include "UbloxATCellularInterfaceExt.h"
+#include "APN_db.h"
+#if defined(FEATURE_COMMON_PAL)
+#include "mbed_trace.h"
+#define TRACE_GROUP "UCAD"
+#else
+#define debug_if(_debug_trace_on, ...) (void(0)) // dummies if feature common pal is not added
+#define tr_info(...)  (void(0)) // dummies if feature common pal is not added
+#define tr_error(...) (void(0)) // dummies if feature common pal is not added
+#endif
+
+/**********************************************************************
+ * PROTECTED METHODS: HTTP
+ **********************************************************************/
+
+// Callback for HTTP result code handling.
+void UbloxATCellularInterfaceExt::UUHTTPCR_URC()
+{
+    char buf[32];
+    int a, b, c;
+
+    // Note: not calling _at->recv() from here as we're
+    // already in an _at->recv()
+    // +UUHTTPCR: <profile_id>,<op_code>,<param_val>
+    if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
+        if (sscanf(buf, ": %d,%d,%d", &a, &b, &c) == 3) {
+            _httpProfiles[a].cmd = b;          // Command
+            _httpProfiles[a].result = c;       // Result
+            debug_if(_debug_trace_on, "%s on profile %d, result code is %d\n", getHttpCmd((HttpCmd) b), a, c);
+        }
+    }
+}
+
+// Find a given profile.  NOTE: LOCK() before calling.
+int UbloxATCellularInterfaceExt::findProfile(int modemHandle)
+{
+    for (unsigned int profile = 0; profile < (sizeof(_httpProfiles)/sizeof(_httpProfiles[0]));
+         profile++) {
+        if (_httpProfiles[profile].modemHandle == modemHandle) {
+            return profile;
+        }
+    }
+
+    return HTTP_PROF_UNUSED;
+}
+
+// Return a string representing an HTTP AT command.
+const char *UbloxATCellularInterfaceExt::getHttpCmd(HttpCmd httpCmd)
+{
+    const char * str = "HTTP command not recognised";
+
+    switch (httpCmd) {
+        case HTTP_HEAD:
+            str = "HTTP HEAD command";
+            break;
+        case HTTP_GET:
+            str = "HTTP GET command";
+            break;
+        case HTTP_DELETE:
+            str = "HTTP DELETE command";
+            break;
+        case HTTP_PUT:
+            str = "HTTP PUT command";
+            break;
+        case HTTP_POST_FILE:
+            str = "HTTP POST file command";
+            break;
+        case HTTP_POST_DATA:
+            str = "HTTP POST data command";
+            break;
+        default:
+            break;
+    }
+
+    return str;
+}
+
+/**********************************************************************
+ * PROTECTED METHODS: FTP
+ **********************************************************************/
+
+// Callback for FTP result code handling.
+void UbloxATCellularInterfaceExt::UUFTPCR_URC()
+{
+    char buf[64];
+    char md5[32];
+
+    // Note: not calling _at->recv() from here as we're
+    // already in an _at->recv()
+    // +UUFTPCR: <op_code>,<ftp_result>[,<md5_sum>]
+    if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
+        if (sscanf(buf, ": %d,%d,%32[^\n]\n", &_lastFtpOpCodeResult, &_lastFtpResult, md5) == 3) {
+            // Store the MD5 sum if we can
+            if ((_ftpBuf != NULL) && (_ftpBufLen >= 32)) {
+                memcpy (_ftpBuf, md5, 32);
+                if (_ftpBufLen == 33) {
+                    *(buf + 32) = 0; // Add a terminator if there's room
+                }
+            }
+        }
+        debug_if(_debug_trace_on, "%s result code is %d\n",
+                 getFtpCmd((FtpCmd) _lastFtpOpCodeResult), _lastFtpResult);
+    }
+}
+
+// Callback for FTP data handling.
+void UbloxATCellularInterfaceExt::UUFTPCD_URC()
+{
+    char buf[32];
+    char *ftpBufPtr = _ftpBuf;
+    int ftpDataLen;
+
+    // Note: not calling _at->recv() from here as we're
+    // already in an _at->recv()
+    // +UUFTPCD: <op_code>,<ftp_data_len>,<ftp_data_in_quotes>
+    if (read_at_to_char(buf, sizeof(buf), '\"') > 0) {
+        if (sscanf(buf, ": %d,%d,\"", &_lastFtpOpCodeData, &ftpDataLen) == 2) {
+            if ((ftpBufPtr != NULL) && (_ftpBufLen > 0)) {
+                if (ftpDataLen + 1 > _ftpBufLen) { // +1 for terminator
+                    ftpDataLen = _ftpBufLen - 1;
+                }
+                ftpBufPtr += _at->read(ftpBufPtr, ftpDataLen);
+                *ftpBufPtr = 0; // Add terminator
+            }
+        }
+    }
+}
+
+// Return a string representing an FTP AT command.
+const char *UbloxATCellularInterfaceExt::getFtpCmd(FtpCmd ftpCmd)
+{
+    const char * str = "FTP command not recognised";
+
+    switch (ftpCmd) {
+        case FTP_LOGOUT:
+            str = "FTP log out command";
+            break;
+        case FTP_LOGIN:
+            str = "FTP log in command";
+            break;
+        case FTP_DELETE_FILE:
+            str = "FTP delete file command";
+            break;
+        case FTP_RENAME_FILE:
+            str = "FTP rename file command";
+            break;
+        case FTP_GET_FILE:
+            str = "FTP get file command";
+            break;
+        case FTP_PUT_FILE:
+            str = "FTP put file command";
+            break;
+        case FTP_CD:
+            str = "FTP change directory command";
+            break;
+        case FTP_MKDIR:
+            str = "FTP make directory command";
+            break;
+        case FTP_RMDIR:
+            str = "FTP remove directory command";
+            break;
+        case FTP_FILE_INFO:
+            str = "FTP file info command";
+            break;
+        case FTP_LS:
+            str = "FTP directory list command";
+            break;
+        case FTP_FOTA_FILE:
+            str = "FTP FOTA file command";
+            break;
+        default:
+            break;
+    }
+
+    return str;
+}
+
+/**********************************************************************
+ * PROTECTED METHODS: Cell Locate
+ **********************************************************************/
+
+// Callback for UULOCIND handling.
+void UbloxATCellularInterfaceExt::UULOCIND_URC()
+{
+    char buf[32];
+    int a, b;
+
+    // Note: not calling _at->recv() from here as we're
+    // already in an _at->recv()
+    // +UULOCIND: <step>,<result>
+    if (read_at_to_char(buf, sizeof (buf), '\n') > 0) {
+        if (sscanf(buf, " %d,%d", &a, &b) == 2) {
+            switch (a) {
+                case 0:
+                    debug_if(_debug_trace_on, "Network scan start\n");
+                    break;
+                case 1:
+                    debug_if(_debug_trace_on, "Network scan end\n");
+                    break;
+                case 2:
+                    debug_if(_debug_trace_on, "Requesting data from server\n");
+                    break;
+                case 3:
+                    debug_if(_debug_trace_on, "Received data from server\n");
+                    break;
+                case 4:
+                    debug_if(_debug_trace_on, "Sending feedback to server\n");
+                    break;
+                default:
+                    debug_if(_debug_trace_on, "Unknown step\n");
+                    break;
+            }
+            switch (b) {
+                case 0:
+                    // No error
+                    break;
+                case 1:
+                    debug_if(_debug_trace_on, "Wrong URL!\n");
+                    break;
+                case 2:
+                    debug_if(_debug_trace_on, "HTTP error!\n");
+                    break;
+                case 3:
+                    debug_if(_debug_trace_on, "Create socket error!\n");
+                    break;
+                case 4:
+                    debug_if(_debug_trace_on, "Close socket error!\n");
+                    break;
+                case 5:
+                    debug_if(_debug_trace_on, "Write to socket error!\n");
+                    break;
+                case 6:
+                    debug_if(_debug_trace_on, "Read from socket error!\n");
+                    break;
+                case 7:
+                    debug_if(_debug_trace_on, "Connection/DNS error!\n");
+                    break;
+                case 8:
+                    debug_if(_debug_trace_on, "Authentication token problem!\n");
+                    break;
+                case 9:
+                    debug_if(_debug_trace_on, "Generic error!\n");
+                    break;
+                case 10:
+                    debug_if(_debug_trace_on, "User terminated!\n");
+                    break;
+                case 11:
+                    debug_if(_debug_trace_on, "No data from server!\n");
+                    break;
+                default:
+                    debug_if(_debug_trace_on, "Unknown result!\n");
+                    break;
+            }
+        }
+    }
+}
+
+// Callback for UULOC URC handling.
+void UbloxATCellularInterfaceExt::UULOC_URC()
+{
+    int a, b;
+
+    // Note: not calling _at->recv() from here as we're
+    // already in an _at->recv()
+
+    // +UHTTPCR: <profile_id>,<op_code>,<param_val>
+    if (read_at_to_char(urcBuf, sizeof (urcBuf), '\n') > 0) {
+        // +UULOC: <date>,<time>,<lat>,<long>,<alt>,<uncertainty>,<speed>, <direction>,<vertical_acc>,<sensor_used>,<SV_used>,<antenna_status>, <jamming_status>
+        if (sscanf(urcBuf, ": %d/%d/%d,%d:%d:%d.%*d,%f,%f,%d,%d,%d,%d,%d,%d,%d,%*d,%*d",
+                   &_loc[0].time.tm_mday, &_loc[0].time.tm_mon,
+                   &_loc[0].time.tm_year, &_loc[0].time.tm_hour,
+                   &_loc[0].time.tm_min, &_loc[0].time.tm_sec,
+                   &_loc[0].latitude, &_loc[0].longitude, &_loc[0].altitude,
+                   &_loc[0].uncertainty, &_loc[0].speed, &_loc[0].direction,
+                   &_loc[0].verticalAcc,
+                   &b, &_loc[0].svUsed) == 15) {
+            debug_if(_debug_trace_on, "Position found at index 0\n");
+            _loc[0].sensor = (b == 0) ? CELL_LAST : (b == 1) ? CELL_GNSS :
+                             (b == 2) ? CELL_LOCATE : (b == 3) ? CELL_HYBRID : CELL_LAST;
+            _loc[0].time.tm_mon -= 1;
+            _loc[0].time.tm_wday = 0;
+            _loc[0].time.tm_yday = 0;
+            _loc[0].validData = true;
+            _locExpPos=1;
+            _locRcvPos++;
+        // +UULOC: <sol>,<num>,<sensor_used>,<date>,<time>,<lat>,<long>,<alt>,<uncertainty>,<speed>, <direction>,<vertical_acc>,,<SV_used>,<antenna_status>, <jamming_status>
+        } else if (sscanf(urcBuf, ": %d,%d,%d,%d/%d/%d,%d:%d:%d.%*d,%f,%f,%d,%d,%d,%d,%d,%d,%*d,%*d",
+                   &a, &_locExpPos, &b,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_mday,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_mon,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_year,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_hour,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_min,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_sec,
+                   &_loc[CELL_MAX_HYP - 1].latitude,
+                   &_loc[CELL_MAX_HYP - 1].longitude,
+                   &_loc[CELL_MAX_HYP - 1].altitude,
+                   &_loc[CELL_MAX_HYP - 1].uncertainty,
+                   &_loc[CELL_MAX_HYP - 1].speed,
+                   &_loc[CELL_MAX_HYP - 1].direction,
+                   &_loc[CELL_MAX_HYP - 1].verticalAcc,
+                   &_loc[CELL_MAX_HYP - 1].svUsed) == 17) {
+            if (--a >= 0) {
+                debug_if(_debug_trace_on, "Position found at index %d\n", a);
+
+                memcpy(&_loc[a], &_loc[CELL_MAX_HYP - 1], sizeof(*_loc));
+
+                _loc[a].sensor = (b == 0) ? CELL_LAST : (b == 1) ? CELL_GNSS :
+                                 (b == 2) ? CELL_LOCATE : (b == 3) ? CELL_HYBRID : CELL_LAST;
+                _loc[a].time.tm_mon -= 1;
+                _loc[a].time.tm_wday = 0;
+                _loc[a].time.tm_yday = 0;
+                _loc[a].validData = true;
+                _locRcvPos++;
+            }
+        //+UULOC: <sol>,<num>,<sensor_used>,<date>,<time>,<lat>,<long>,<alt>,<lat50>,<long50>,<major50>,<minor50>,<orientation50>,<confidence50>[,<lat95>,<long95>,<major95>,<minor95>,<orientation95>,<confidence95>]
+        } else if (sscanf(urcBuf, ": %d,%d,%d,%d/%d/%d,%d:%d:%d.%*d,%f,%f,%d,%*f,%*f,%d,%*d,%*d,%*d",
+                   &a, &_locExpPos, &b,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_mday,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_mon,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_year,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_hour,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_min,
+                   &_loc[CELL_MAX_HYP - 1].time.tm_sec,
+                   &_loc[CELL_MAX_HYP - 1].latitude,
+                   &_loc[CELL_MAX_HYP - 1].longitude,
+                   &_loc[CELL_MAX_HYP - 1].altitude,
+                   &_loc[CELL_MAX_HYP - 1].uncertainty) == 13) {
+            if (--a >= 0) {
+
+                debug_if(_debug_trace_on, "Position found at index %d\n", a);
+
+                memcpy(&_loc[a], &_loc[CELL_MAX_HYP - 1], sizeof(*_loc));
+
+                _loc[a].sensor = (b == 0) ? CELL_LAST : (b == 1) ? CELL_GNSS :
+                                 (b == 2) ? CELL_LOCATE : (b == 3) ? CELL_HYBRID : CELL_LAST;
+                _loc[a].time.tm_mon -= 1;
+                _loc[a].time.tm_wday = 0;
+                _loc[a].time.tm_yday = 0;
+                _loc[a].validData = true;
+                _locRcvPos++;
+            }
+        }
+    }
+}
+
+/**********************************************************************
+ * PUBLIC METHODS: GENERAL
+ **********************************************************************/
+
+// Constructor.
+UbloxATCellularInterfaceExt::UbloxATCellularInterfaceExt(PinName tx,
+                                                         PinName rx,
+                                                         int baud,
+                                                         bool debugOn):
+                             UbloxATCellularInterface(tx, rx, baud, debugOn)
+{
+    // Zero HTTP stuff
+    memset(_httpProfiles, 0, sizeof(_httpProfiles));
+    for (unsigned int profile = 0; profile < sizeof(_httpProfiles) / sizeof(_httpProfiles[0]);
+         profile++) {
+        _httpProfiles[profile].modemHandle = HTTP_PROF_UNUSED;
+    }
+
+    // Zero FTP stuff
+    _ftpTimeout = TIMEOUT_BLOCKING;
+    _lastFtpOpCodeResult = FTP_OP_CODE_UNUSED;
+    _lastFtpResult = 0;
+    _lastFtpOpCodeData = FTP_OP_CODE_UNUSED;
+    _ftpBuf = NULL;
+    _ftpBufLen = 0;
+    _ftpError.eClass = 0;
+    _ftpError.eCode = 0;
+
+    // Zero Cell Locate stuff
+    _locRcvPos = 0;
+    _locExpPos = 0;
+
+    // URC handler for HTTP
+    _at->oob("+UUHTTPCR", callback(this, &UbloxATCellularInterfaceExt::UUHTTPCR_URC));
+
+    // URC handlers for FTP
+    _at->oob("+UUFTPCR", callback(this, &UbloxATCellularInterfaceExt::UUFTPCR_URC));
+    _at->oob("+UUFTPCD", callback(this, &UbloxATCellularInterfaceExt::UUFTPCD_URC));
+
+    // URC handlers for Cell Locate
+    _at->oob("+UULOCIND", callback(this, &UbloxATCellularInterfaceExt::UULOCIND_URC));
+    _at->oob("+UULOC", callback(this, &UbloxATCellularInterfaceExt::UULOC_URC));
+}
+
+// Destructor.
+UbloxATCellularInterfaceExt::~UbloxATCellularInterfaceExt()
+{
+}
+
+/**********************************************************************
+ * PUBLIC METHODS: HTTP
+ **********************************************************************/
+
+// Find a free profile.
+int UbloxATCellularInterfaceExt::httpAllocProfile()
+{
+    int profile = HTTP_PROF_UNUSED;
+    LOCK();
+
+    // Find a free HTTP profile
+    profile = findProfile();
+    debug_if(_debug_trace_on, "httpFindProfile: profile is %d\n", profile);
+
+    if (profile != HTTP_PROF_UNUSED) {
+        _httpProfiles[profile].modemHandle = 1;
+        _httpProfiles[profile].timeout     = TIMEOUT_BLOCKING;
+        _httpProfiles[profile].pending     = false;
+        _httpProfiles[profile].cmd         = -1;
+        _httpProfiles[profile].result      = -1;
+    }
+
+    UNLOCK();
+    return profile;
+}
+
+// Free a profile.
+bool UbloxATCellularInterfaceExt::httpFreeProfile(int profile)
+{
+    bool success = false;
+    LOCK();
+
+    if (IS_PROFILE(profile)) {
+        debug_if(_debug_trace_on, "httpFreeProfile(%d)\n", profile);
+        _httpProfiles[profile].modemHandle = HTTP_PROF_UNUSED;
+        _httpProfiles[profile].timeout     = TIMEOUT_BLOCKING;
+        _httpProfiles[profile].pending     = false;
+        _httpProfiles[profile].cmd         = -1;
+        _httpProfiles[profile].result      = -1;
+        success = _at->send("AT+UHTTP=%d", profile) && _at->recv("OK");
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Set the blocking/timeout state of a profile.
+bool UbloxATCellularInterfaceExt::httpSetTimeout(int profile, int timeout)
+{
+    bool success = false;
+    LOCK();
+
+    debug_if(_debug_trace_on, "httpSetTimeout(%d, %d)\n", profile, timeout);
+
+    if (IS_PROFILE(profile)) {
+        _httpProfiles[profile].timeout = timeout;
+        success = true;
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Set a profile back to defaults.
+bool UbloxATCellularInterfaceExt::httpResetProfile(int httpProfile)
+{
+    bool success = false;
+    LOCK();
+
+    debug_if(_debug_trace_on, "httpResetProfile(%d)\n", httpProfile);
+    success = _at->send("AT+UHTTP=%d", httpProfile) && _at->recv("OK");
+
+    UNLOCK();
+    return success;
+}
+
+// Set HTTP parameters.
+bool UbloxATCellularInterfaceExt::httpSetPar(int httpProfile,
+                                             HttpOpCode httpOpCode,
+                                             const char * httpInPar)
+{
+    bool success = false;
+    int httpInParNum = 0;
+    SocketAddress address;
+
+    debug_if(_debug_trace_on, "httpSetPar(%d, %d, \"%s\")\n", httpProfile, httpOpCode, httpInPar);
+    if (IS_PROFILE(httpProfile)) {
+        LOCK();
+
+        switch(httpOpCode) {
+            case HTTP_IP_ADDRESS:   // 0
+                if (gethostbyname(httpInPar, &address) == NSAPI_ERROR_OK) {
+                    success = _at->send("AT+UHTTP=%d,%d,\"%s\"",
+                                        httpProfile, httpOpCode, address.get_ip_address()) &&
+                              _at->recv("OK");
+                }
+                break;
+            case HTTP_SERVER_NAME:  // 1
+            case HTTP_USER_NAME:    // 2
+            case HTTP_PASSWORD:     // 3
+                success = _at->send("AT+UHTTP=%d,%d,\"%s\"", httpProfile, httpOpCode, httpInPar) &&
+                          _at->recv("OK");
+                break;
+
+            case HTTP_AUTH_TYPE:    // 4
+            case HTTP_SERVER_PORT:  // 5
+                httpInParNum = atoi(httpInPar);
+                success = _at->send("AT+UHTTP=%d,%d,%d", httpProfile, httpOpCode, httpInParNum) &&
+                          _at->recv("OK");
+                break;
+
+            case HTTP_SECURE:       // 6
+                httpInParNum = atoi(httpInPar);
+                success = _at->send("AT+UHTTP=%d,%d,%d", httpProfile, httpOpCode, httpInParNum) &&
+                          _at->recv("OK");
+                break;
+
+            default:
+                debug_if(_debug_trace_on, "httpSetPar: unknown httpOpCode %d\n", httpOpCode);
+                break;
+        }
+
+        UNLOCK();
+    }
+
+    return success;
+}
+
+// Perform an HTTP command.
+UbloxATCellularInterfaceExt::Error * UbloxATCellularInterfaceExt::httpCommand(int httpProfile,
+                                                                              HttpCmd httpCmd,
+                                                                              const char *httpPath,
+                                                                              const char *rspFile,
+                                                                              const char *sendStr,
+                                                                              int httpContentType,
+                                                                              const char *httpCustomPar,
+                                                                              char *buf, int len)
+{
+    bool atSuccess = false;
+    bool success = false;
+    int at_timeout;
+    char defaultFilename[] = "http_last_response_x";
+
+    debug_if(_debug_trace_on, "%s\n", getHttpCmd(httpCmd));
+
+    if (IS_PROFILE(httpProfile)) {
+        LOCK();
+        at_timeout = _at_timeout; // Has to be inside LOCK()s
+
+        if (rspFile == NULL) {
+            sprintf(defaultFilename + sizeof (defaultFilename) - 2, "%1d", httpProfile);
+            rspFile = defaultFilename;
+        }
+
+        switch (httpCmd) {
+            case HTTP_HEAD:
+                atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\"", httpProfile, httpCmd,
+                                      httpPath, rspFile) &&
+                            _at->recv("OK");
+                break;
+            case HTTP_GET:
+                atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\"", httpProfile, httpCmd,
+                                      httpPath, rspFile) &&
+                            _at->recv("OK");
+                break;
+            case HTTP_DELETE:
+                atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\"", httpProfile, httpCmd,
+                                      httpPath, rspFile) &&
+                            _at->recv("OK");
+                break;
+            case HTTP_PUT:
+                // In this case the parameter sendStr is a filename
+                atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\",\"%s\"", httpProfile, httpCmd,
+                                      httpPath, rspFile, sendStr) &&
+                            _at->recv("OK");
+                break;
+            case HTTP_POST_FILE:
+                // In this case the parameter sendStr is a filename
+                if (httpContentType != 6) {
+                    atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\",\"%s\",%d",
+                                          httpProfile, httpCmd, httpPath, rspFile, sendStr,
+                                          httpContentType) &&
+                                _at->recv("OK");
+                } else {
+                    atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\",\"%s\",%d,%s",
+                                          httpProfile, httpCmd, httpPath, rspFile, sendStr,
+                                          httpContentType,
+                                          httpCustomPar) &&
+                                _at->recv("OK");
+                }
+                break;
+            case HTTP_POST_DATA:
+                // In this case the parameter sendStr is a string containing data
+                if (httpContentType != 6) {
+                    atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\",\"%s\",%d",
+                                          httpProfile, httpCmd, httpPath, rspFile, sendStr,
+                                          httpContentType) &&
+                                _at->recv("OK");
+                } else {
+                    atSuccess = _at->send("AT+UHTTPC=%d,%d,\"%s\",\"%s\",\"%s\",%d,%s",
+                                          httpProfile, httpCmd, httpPath, rspFile, sendStr,
+                                          httpContentType,
+                                          httpCustomPar) &&
+                                _at->recv("OK");
+                }
+                break;
+            default:
+                debug_if(_debug_trace_on, "HTTP command not recognised\n");
+                break;
+        }
+
+        if (atSuccess) {
+            Timer timer;
+
+            at_set_timeout(1000);
+            _httpProfiles[httpProfile].pending = true;
+            _httpProfiles[httpProfile].result = -1;
+
+            // Waiting for unsolicited result code
+            timer.start();
+            while (_httpProfiles[httpProfile].pending) {
+                if (_httpProfiles[httpProfile].result != -1) {
+                    // Received unsolicited: starting its analysis
+                    _httpProfiles[httpProfile].pending = false;
+                    if (_httpProfiles[httpProfile].result == 1) {
+                        // HTTP command successfully executed
+                        if (readFile(rspFile, buf, len) >= 0) {
+                            success = true;
+                        }
+                    } else {
+                        // Retrieve the error class and code
+                        if (_at->send("AT+UHTTPER=%d", httpProfile) &&
+                            _at->recv("AT+UHTTPER=%*d,%d,%d",
+                                      &(_httpProfiles[httpProfile].httpError.eClass),
+                                      &(_httpProfiles[httpProfile].httpError.eCode)) &&
+                            _at->recv("OK")) {
+                            debug_if(_debug_trace_on, "HTTP error class %d, code %d\n",
+                                    _httpProfiles[httpProfile].httpError.eClass,
+                                    _httpProfiles[httpProfile].httpError.eCode);
+                        }
+                    }
+                } else if (!TIMEOUT(timer, _httpProfiles[httpProfile].timeout)) {
+                    // Wait for URCs
+                    _at->recv(UNNATURAL_STRING);
+                } else  {
+                    _httpProfiles[httpProfile].pending = false;
+                }
+            }
+            timer.stop();
+
+            at_set_timeout(at_timeout);
+
+            if (!success) {
+                debug_if(_debug_trace_on, "%s: ERROR\n", getHttpCmd(httpCmd));
+            }
+
+        }
+
+        UNLOCK();
+    }
+
+    return success ? NULL : &(_httpProfiles[httpProfile].httpError);
+}
+
+/**********************************************************************
+ * PUBLIC METHODS: FTP
+ **********************************************************************/
+
+// Set the blocking/timeout for FTP.
+bool UbloxATCellularInterfaceExt::ftpSetTimeout(int timeout)
+{
+    LOCK();
+    debug_if(_debug_trace_on, "ftpSetTimeout(%d)\n", timeout);
+    _ftpTimeout = timeout;
+    UNLOCK();
+
+    return true;
+}
+
+// Reset the FTP configuration back to defaults.
+bool UbloxATCellularInterfaceExt::ftpResetPar()
+{
+    bool success = true;
+    LOCK();
+
+    debug_if(_debug_trace_on, "ftpResetPar()\n");
+    for (int x = 0; success && (x < NUM_FTP_OP_CODES); x++) {
+        success = _at->send("AT+UFTP=%d", x) && _at->recv("OK");
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Set FTP parameters.
+bool UbloxATCellularInterfaceExt::ftpSetPar(FtpOpCode ftpOpCode,
+                                            const char * ftpInPar)
+{
+    bool success = false;
+    int ftpInParNum = 0;
+    LOCK();
+
+    debug_if(_debug_trace_on, "ftpSetPar(%d, %s)\n", ftpOpCode, ftpInPar);
+    switch (ftpOpCode) {
+        case FTP_IP_ADDRESS:         // 0
+        case FTP_SERVER_NAME:        // 1
+        case FTP_USER_NAME:          // 2
+        case FTP_PASSWORD:           // 3
+        case FTP_ACCOUNT:            // 4
+            success = _at->send("AT+UFTP=%d,\"%s\"", ftpOpCode, ftpInPar) &&
+                      _at->recv("OK");
+            break;
+        case FTP_INACTIVITY_TIMEOUT: // 5
+        case FTP_MODE:               // 6
+        case FTP_SERVER_PORT:        // 7
+        case FTP_SECURE:             // 8
+            ftpInParNum = atoi(ftpInPar);
+            success = _at->send("AT+UFTP=%d,%d", ftpOpCode, ftpInParNum) &&
+                      _at->recv("OK");
+            break;
+        default:
+            debug_if(_debug_trace_on, "ftpSetPar: unknown ftpOpCode %d\n", ftpOpCode);
+            break;
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Perform an FTP command.
+UbloxATCellularInterfaceExt::Error * UbloxATCellularInterfaceExt::ftpCommand(FtpCmd ftpCmd,
+                                                                             const char* file1,
+                                                                             const char* file2,
+                                                                             int offset,
+                                                                             char* buf, int len)
+{
+    bool atSuccess = false;
+    bool success = false;
+    int at_timeout;
+    LOCK();
+    at_timeout = _at_timeout; // Has to be inside LOCK()s
+
+    debug_if(_debug_trace_on, "%s\n", getFtpCmd(ftpCmd));
+    switch (ftpCmd) {
+        case FTP_LOGOUT:
+        case FTP_LOGIN:
+            atSuccess = _at->send("AT+UFTPC=%d", ftpCmd) && _at->recv("OK");
+            break;
+        case FTP_DELETE_FILE:
+        case FTP_CD:
+        case FTP_MKDIR:
+        case FTP_RMDIR:
+        case FTP_FOTA_FILE:
+            atSuccess = _at->send("AT+UFTPC=%d,\"%s\"", ftpCmd, file1) &&
+                        _at->recv("OK");
+            break;
+        case FTP_RENAME_FILE:
+            atSuccess = _at->send("AT+UFTPC=%d,\"%s\",\"%s\"",
+                                  ftpCmd, file1, file2) &&
+                        _at->recv("OK");
+            break;
+        case FTP_GET_FILE:
+        case FTP_PUT_FILE:
+            if (file2 == NULL) {
+                file2 = file1;
+            }
+            atSuccess = _at->send("AT+UFTPC=%d,\"%s\",\"%s\",%d",
+                                  ftpCmd, file1, file2, offset) &&
+                        _at->recv("OK");
+            break;
+        case FTP_FILE_INFO:
+        case FTP_LS:
+            _ftpBuf = buf;
+            _ftpBufLen = len;
+            // Add a terminator in case nothing comes back
+            if (_ftpBufLen > 0) {
+                *_ftpBuf = 0;
+            }
+            if (file1 == NULL) {
+                atSuccess = _at->send("AT+UFTPC=%d", ftpCmd) &&
+                            _at->recv("OK");
+            } else {
+                atSuccess = _at->send("AT+UFTPC=%d,\"%s\"", ftpCmd, file1) &&
+                            _at->recv("OK");
+            }
+            break;
+        default:
+            debug_if(_debug_trace_on, "FTP command not recognised/supported\n");
+            break;
+    }
+
+    // Wait for the result to arrive back
+    if (atSuccess) {
+        Timer timer;
+
+        at_set_timeout(1000);
+        _lastFtpOpCodeData = FTP_OP_CODE_UNUSED;
+        _lastFtpOpCodeResult = FTP_OP_CODE_UNUSED;
+        _lastFtpResult = -1; // just for safety
+        // Waiting for result to arrive
+        timer.start();
+        while ((_lastFtpOpCodeResult == FTP_OP_CODE_UNUSED) &&
+                !TIMEOUT(timer, _ftpTimeout)) {
+            _at->recv(UNNATURAL_STRING);
+        }
+        timer.stop();
+
+        if ((_lastFtpOpCodeResult == ftpCmd) && (_lastFtpResult == 1)) {
+            // Got a result for our FTP op code and it is good
+            success = true;
+        } else {
+            // Retrieve the error class and code
+            if (_at->send("AT+UFTPER") &&
+                _at->recv("+UFTPER:%d,%d", &(_ftpError.eClass), &(_ftpError.eCode)) &&
+                _at->recv("OK")) {
+                debug_if(_debug_trace_on, "FTP Error class %d, code %d\n",
+                         _ftpError.eClass, _ftpError.eCode);
+            }
+        }
+
+        at_set_timeout(at_timeout);
+
+        if (!success) {
+            debug_if(_debug_trace_on, "%s: ERROR\n", getFtpCmd(ftpCmd));
+        }
+    }
+
+    // Set these back to nothing to stop the URC splatting
+    _ftpBuf = NULL;
+    _ftpBufLen = 0;
+
+    UNLOCK();
+    return success ? NULL : &_ftpError;
+}
+
+/**********************************************************************
+ * PUBLIC METHODS: Cell Locate
+ **********************************************************************/
+
+// Configure CellLocate TCP Aiding server.
+bool UbloxATCellularInterfaceExt::cellLocSrvTcp(const char* token,
+                                                const char* server_1,
+                                                const char* server_2,
+                                                int days, int period,
+                                                int resolution)
+{
+    bool success = false;
+    LOCK();
+
+    if ((_dev_info.dev == DEV_LISA_U2_03S) || (_dev_info.dev  == DEV_SARA_U2)){
+        success = _at->send("AT+UGSRV=\"%s\",\"%s\",\"%s\",%d,%d,%d",
+                            server_1, server_2, token, days, period, resolution) &&
+                  _at->recv("OK");
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Configure CellLocate UDP Aiding server.
+bool UbloxATCellularInterfaceExt::cellLocSrvUdp(const char* server_1,
+                                                int port, int latency,
+                                                int mode)
+{
+
+    bool success = false;
+    LOCK();
+
+    if (_dev_info.dev != DEV_TOBY_L2) {
+        success = _at->send("AT+UGAOP=\"%s\",%d,%d,%d", server_1, port, latency, mode) &&
+                  _at->recv("OK");
+    }
+
+    UNLOCK();
+    return success;
+}
+
+// Configure Cell Locate location sensor.
+bool UbloxATCellularInterfaceExt::cellLocConfig(int scanMode)
+{
+    bool success;
+    LOCK();
+
+    success = _at->send("AT+ULOCCELL=%d", scanMode) &&
+              _at->recv("OK");
+
+    UNLOCK();
+    return success;
+}
+
+// Request CellLocate.
+bool UbloxATCellularInterfaceExt::cellLocRequest(CellSensType sensor,
+                                                 int timeout,
+                                                 int accuracy,
+                                                 CellRespType type,
+                                                 int hypothesis)
+{
+    bool success = false;
+
+    if ((hypothesis <= CELL_MAX_HYP) &&
+        !((hypothesis > 1) && (type != CELL_MULTIHYP))) {
+
+        LOCK();
+
+        _locRcvPos = 0;
+        _locExpPos = 0;
+
+        for (int i = 0; i < hypothesis; i++) {
+            _loc[i].validData = false;
+        }
+
+        // Switch on the URC
+        if (_at->send("AT+ULOCIND=1") && _at->recv("OK")) {
+            // Switch on Cell Locate
+            success = _at->send("AT+ULOC=2,%d,%d,%d,%d,%d", sensor, type, timeout, accuracy, hypothesis) &&
+                      _at->recv("OK");
+            // Answers are picked up by the URC
+        }
+
+        UNLOCK();
+    }
+
+    return success;
+}
+
+// Get a position record.
+bool UbloxATCellularInterfaceExt::cellLocGetData(CellLocData *data, int index)
+{
+    bool success = false;
+
+    if (_loc[index].validData) {
+        LOCK();
+        memcpy(data, &_loc[index], sizeof(*_loc));
+        success = true;
+        UNLOCK();
+    }
+
+    return success;
+}
+
+// Get number of position records received.
+int UbloxATCellularInterfaceExt::cellLocGetRes()
+{
+    int at_timeout;
+    LOCK();
+
+    at_timeout = _at_timeout; // Has to be inside LOCK()s
+    at_set_timeout(1000);
+    // Wait for URCs
+    _at->recv(UNNATURAL_STRING);
+    at_set_timeout(at_timeout);
+
+    UNLOCK();
+    return _locRcvPos;
+}
+
+// Get number of positions records expected to be received.
+int UbloxATCellularInterfaceExt::cellLocGetExpRes()
+{
+    int numRecords = 0;
+    LOCK();
+
+    _at->recv("OK");
+
+    if (_locRcvPos > 0) {
+        numRecords = _locExpPos;
+    }
+
+    UNLOCK();
+    return numRecords;
+}
+
+// End of file
+