Merge branch 'master' of github.com:mavlink/qgroundcontrol into my_qt5

libs/mavlink/include/mavlink/v1.0/checksum.h

@@ -73,7 +73,7 @@ static inline uint16_t crc_calculate(const uint8_t* pBuffer, uint16_t length)
  * @param data new bytes to hash
  * @param crcAccum the already accumulated checksum
  **/
-static inline void crc_accumulate_buffer(uint16_t *crcAccum, const char *pBuffer, uint8_t length)
+static inline void crc_accumulate_buffer(uint16_t *crcAccum, const char *pBuffer, uint16_t length)
 {
 	const uint8_t *p = (const uint8_t *)pBuffer;
 	while (length--) {

libs/mavlink/include/mavlink/v1.0/common/common.h

@@ -5,6 +5,10 @@
 #ifndef COMMON_H
 #define COMMON_H
 
+#ifndef MAVLINK_H
+ #error Wrong include order: common.h MUST NOT BE DIRECTLY USED. Include mavlink.h from the same directory instead or set all defines from mavlink.h manually.
+#endif
+
 #ifdef __cplusplus
 extern "C" {
 #endif

libs/mavlink/include/mavlink/v1.0/mavlink_helpers.h

@@ -73,7 +73,6 @@ MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, ui
 #endif
 {
 	// This code part is the same for all messages;
-	uint16_t checksum;
 	msg->magic = MAVLINK_STX;
 	msg->len = length;
 	msg->sysid = system_id;
@@ -81,12 +80,13 @@ MAVLINK_HELPER uint16_t mavlink_finalize_message_chan(mavlink_message_t* msg, ui
 	// One sequence number per component
 	msg->seq = mavlink_get_channel_status(chan)->current_tx_seq;
 	mavlink_get_channel_status(chan)->current_tx_seq = mavlink_get_channel_status(chan)->current_tx_seq+1;
-	checksum = crc_calculate((uint8_t*)&msg->len, length + MAVLINK_CORE_HEADER_LEN);
+	msg->checksum = crc_calculate(((const uint8_t*)(msg)) + 3, MAVLINK_CORE_HEADER_LEN);
+	crc_accumulate_buffer(&msg->checksum, _MAV_PAYLOAD(msg), msg->len);
 #if MAVLINK_CRC_EXTRA
-	crc_accumulate(crc_extra, &checksum);
+	crc_accumulate(crc_extra, &msg->checksum);
 #endif
-	mavlink_ck_a(msg) = (uint8_t)(checksum & 0xFF);
-	mavlink_ck_b(msg) = (uint8_t)(checksum >> 8);
+	mavlink_ck_a(msg) = (uint8_t)(msg->checksum & 0xFF);
+	mavlink_ck_b(msg) = (uint8_t)(msg->checksum >> 8);
 
 	return length + MAVLINK_NUM_NON_PAYLOAD_BYTES;
 }
@@ -133,7 +133,7 @@ MAVLINK_HELPER void _mav_finalize_message_chan_send(mavlink_channel_t chan, uint
 	buf[4] = mavlink_system.compid;
 	buf[5] = msgid;
 	status->current_tx_seq++;
-	checksum = crc_calculate((uint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
+	checksum = crc_calculate((const uint8_t*)&buf[1], MAVLINK_CORE_HEADER_LEN);
 	crc_accumulate_buffer(&checksum, packet, length);
 #if MAVLINK_CRC_EXTRA
 	crc_accumulate(crc_extra, &checksum);
@@ -158,6 +158,7 @@ MAVLINK_HELPER void _mavlink_resend_uart(mavlink_channel_t chan, const mavlink_m
 
 	ck[0] = (uint8_t)(msg->checksum & 0xFF);
 	ck[1] = (uint8_t)(msg->checksum >> 8);
+	// XXX use the right sequence here
 
 	MAVLINK_START_UART_SEND(chan, MAVLINK_NUM_NON_PAYLOAD_BYTES + msg->len);
 	_mavlink_send_uart(chan, (const char *)&msg->magic, MAVLINK_NUM_HEADER_BYTES);
@@ -172,7 +173,13 @@ MAVLINK_HELPER void _mavlink_resend_uart(mavlink_channel_t chan, const mavlink_m
  */
 MAVLINK_HELPER uint16_t mavlink_msg_to_send_buffer(uint8_t *buffer, const mavlink_message_t *msg)
 {
-	memcpy(buffer, (const uint8_t *)&msg->magic, MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len);
+	memcpy(buffer, (const uint8_t *)&msg->magic, MAVLINK_NUM_HEADER_BYTES + (uint16_t)msg->len);
+
+	uint8_t *ck = buffer + (MAVLINK_NUM_HEADER_BYTES + (uint16_t)msg->len);
+
+	ck[0] = (uint8_t)(msg->checksum & 0xFF);
+	ck[1] = (uint8_t)(msg->checksum >> 8);
+
 	return MAVLINK_NUM_NON_PAYLOAD_BYTES + (uint16_t)msg->len;
 }
 

libs/mavlink/include/mavlink/v1.0/mavlink_types.h

@@ -28,6 +28,7 @@
 
 #define MAVLINK_MAX_EXTENDED_PAYLOAD_LEN (MAVLINK_MAX_EXTENDED_PACKET_LEN - MAVLINK_EXTENDED_HEADER_LEN - MAVLINK_NUM_NON_PAYLOAD_BYTES)
 
+#pragma pack(push, 1)
 typedef struct param_union {
 	union {
 		float param_float;
@@ -62,13 +63,12 @@ typedef struct __mavlink_message {
 	uint64_t payload64[(MAVLINK_MAX_PAYLOAD_LEN+MAVLINK_NUM_CHECKSUM_BYTES+7)/8];
 } mavlink_message_t;
 
-
 typedef struct __mavlink_extended_message {
        mavlink_message_t base_msg;
        int32_t extended_payload_len;   ///< Length of extended payload if any
        uint8_t extended_payload[MAVLINK_MAX_EXTENDED_PAYLOAD_LEN];
 } mavlink_extended_message_t;
-
+#pragma pack(pop)
 
 typedef enum {
 	MAVLINK_TYPE_CHAR     = 0,

qgroundcontrol.pro

@@ -191,22 +191,27 @@ DebugBuild {
         src/qgcunittest/MockUASManager.h \
         src/qgcunittest/MockUAS.h \
         src/qgcunittest/MockQGCUASParamManager.h \
+        src/qgcunittest/MockMavlinkInterface.h \
+        src/qgcunittest/MockMavlinkFileServer.h \
         src/qgcunittest/MultiSignalSpy.h \
         src/qgcunittest/FlightModeConfigTest.h \
         src/qgcunittest/FlightGearTest.h \
         src/qgcunittest/TCPLinkTest.h \
-        src/qgcunittest/TCPLoopBackServer.h
+        src/qgcunittest/TCPLoopBackServer.h \
+        src/qgcunittest/QGCUASFileManagerTest.h
 
     SOURCES += \
         src/qgcunittest/UASUnitTest.cc \
         src/qgcunittest/MockUASManager.cc \
         src/qgcunittest/MockUAS.cc \
         src/qgcunittest/MockQGCUASParamManager.cc \
+        src/qgcunittest/MockMavlinkFileServer.cc \
         src/qgcunittest/MultiSignalSpy.cc \
         src/qgcunittest/FlightModeConfigTest.cc \
         src/qgcunittest/FlightGearTest.cc \
         src/qgcunittest/TCPLinkTest.cc \
-        src/qgcunittest/TCPLoopBackServer.cc
+        src/qgcunittest/TCPLoopBackServer.cc \
+        src/qgcunittest/QGCUASFileManagerTest.cc
 }
 
 #
@@ -301,6 +306,7 @@ FORMS += \
     src/ui/designer/QGCCommandButton.ui \
     src/ui/QGCMAVLinkLogPlayer.ui \
     src/ui/QGCWaypointListMulti.ui \
+    src/ui/QGCUASFileViewMulti.ui \
     src/ui/QGCUDPLinkConfiguration.ui \
     src/ui/QGCTCPLinkConfiguration.ui \
     src/ui/QGCSettingsWidget.ui \
@@ -378,7 +384,8 @@ FORMS += \
     src/ui/px4_configuration/QGCPX4AirframeConfig.ui \
     src/ui/px4_configuration/QGCPX4MulticopterConfig.ui \
     src/ui/px4_configuration/QGCPX4SensorCalibration.ui \
-    src/ui/designer/QGCXYPlot.ui
+    src/ui/designer/QGCXYPlot.ui \
+    src/ui/QGCUASFileView.ui
 
 HEADERS += \
     src/MG.h \
@@ -466,6 +473,7 @@ HEADERS += \
     src/comm/MAVLinkSimulationMAV.h \
     src/uas/QGCMAVLinkUASFactory.h \
     src/ui/QGCWaypointListMulti.h \
+    src/ui/QGCUASFileViewMulti.h \
     src/ui/QGCUDPLinkConfiguration.h \
     src/ui/QGCTCPLinkConfiguration.h \
     src/ui/QGCSettingsWidget.h \
@@ -572,6 +580,8 @@ HEADERS += \
     src/ui/menuactionhelper.h \
     src/uas/UASManagerInterface.h \
     src/uas/QGCUASParamManagerInterface.h \
+    src/uas/QGCUASFileManager.h \
+    src/ui/QGCUASFileView.h \
     src/uas/QGCUASWorker.h \
     src/CmdLineOptParser.h \
     src/uas/QGXPX4UAS.h
@@ -656,6 +666,7 @@ SOURCES += \
     src/comm/MAVLinkSimulationMAV.cc \
     src/uas/QGCMAVLinkUASFactory.cc \
     src/ui/QGCWaypointListMulti.cc \
+    src/ui/QGCUASFileViewMulti.cc \
     src/ui/QGCUDPLinkConfiguration.cc \
     src/ui/QGCTCPLinkConfiguration.cc \
     src/ui/QGCSettingsWidget.cc \
@@ -758,6 +769,8 @@ SOURCES += \
     src/ui/px4_configuration/QGCPX4SensorCalibration.cc \
     src/ui/designer/QGCXYPlot.cc \
     src/ui/menuactionhelper.cpp \
+    src/uas/QGCUASFileManager.cc \
+    src/ui/QGCUASFileView.cc \
     src/uas/QGCUASWorker.cc \
     src/CmdLineOptParser.cc \
     src/uas/QGXPX4UAS.cc

src/qgcunittest/MockMavlinkFileServer.cc

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#include "MockMavlinkFileServer.h"
+
+const MockMavlinkFileServer::FileTestCase MockMavlinkFileServer::rgFileTestCases[MockMavlinkFileServer::cFileTestCases] = {
+    // File fits one Read Ack packet, partially filling data
+    { "partial.qgc",    sizeof(((QGCUASFileManager::Request*)0)->data) - 1 },
+    // File fits one Read Ack packet, exactly filling all data
+    { "exact.qgc",      sizeof(((QGCUASFileManager::Request*)0)->data) },
+    // File is larger than a single Read Ack packets, requires multiple Reads
+    { "multi.qgc",      sizeof(((QGCUASFileManager::Request*)0)->data) + 1 },
+};
+
+// We only support a single fixed session
+const uint8_t MockMavlinkFileServer::_sessionId = 1;
+
+MockMavlinkFileServer::MockMavlinkFileServer(void)
+{
+
+}
+
+
+
+/// @brief Handles List command requests. Only supports root folder paths.
+///         File list returned is set using the setFileList method.
+void MockMavlinkFileServer::_listCommand(QGCUASFileManager::Request* request)
+{
+    // FIXME: Does not support directories that span multiple packets
+    
+    QGCUASFileManager::Request  ackResponse;
+    QString                     path;
+
+    // We only support root path
+    path = (char *)&request->data[0];
+    if (!path.isEmpty() && path != "/") {
+        _sendNak(QGCUASFileManager::kErrNotDir);
+        return;
+    }
+    
+    // Offset requested is past the end of the list
+    if (request->hdr.offset > (uint32_t)_fileList.size()) {
+        _sendNak(QGCUASFileManager::kErrEOF);
+        return;
+    }
+    
+    ackResponse.hdr.magic = 'f';
+    ackResponse.hdr.opcode = QGCUASFileManager::kRspAck;
+    ackResponse.hdr.session = 0;
+    ackResponse.hdr.offset = request->hdr.offset;
+    ackResponse.hdr.size = 0;
+
+    if (request->hdr.offset == 0) {
+        // Requesting first batch of file names
+        Q_ASSERT(_fileList.size());
+        char *bufPtr = (char *)&ackResponse.data[0];
+        for (int i=0; i<_fileList.size(); i++) {
+            strcpy(bufPtr, _fileList[i].toStdString().c_str());
+            size_t cchFilename = strlen(bufPtr);
+			Q_ASSERT(cchFilename);
+            ackResponse.hdr.size += cchFilename + 1;
+            bufPtr += cchFilename + 1;
+        }
+
+        _emitResponse(&ackResponse);
+    } else {
+        // FIXME: Does not support directories that span multiple packets
+        _sendNak(QGCUASFileManager::kErrEOF);
+    }
+}
+
+/// @brief Handles Open command requests.
+void MockMavlinkFileServer::_openCommand(QGCUASFileManager::Request* request)
+{
+    QGCUASFileManager::Request  response;
+    QString                     path;
+    
+    size_t cchPath = strnlen((char *)request->data, sizeof(request->data));
+    Q_ASSERT(cchPath != sizeof(request->data));
+    path = (char *)request->data;
+    
+    // Check path against one of our known test cases
+
+    bool found = false;
+    for (size_t i=0; i<cFileTestCases; i++) {
+        if (path == rgFileTestCases[i].filename) {
+            found = true;
+            _readFileLength = rgFileTestCases[i].length;
+            break;
+        }
+    }
+    if (!found) {
+        _sendNak(QGCUASFileManager::kErrNotFile);
+        return;
+    }
+    
+    response.hdr.magic = 'f';
+    response.hdr.opcode = QGCUASFileManager::kRspAck;
+    response.hdr.session = _sessionId;
+    response.hdr.size = 0;
+    
+    _emitResponse(&response);
+}
+
+/// @brief Handles Read command requests.
+void MockMavlinkFileServer::_readCommand(QGCUASFileManager::Request* request)
+{
+    QGCUASFileManager::Request response;
+
+    if (request->hdr.session != _sessionId) {
+        _sendNak(QGCUASFileManager::kErrNoSession);
+        return;
+    }
+    
+    uint32_t readOffset = request->hdr.offset;  // offset into file for reading
+    uint8_t cDataBytes = 0;                     // current number of data bytes used
+    
+    if (readOffset >= _readFileLength) {
+        _sendNak(QGCUASFileManager::kErrEOF);
+        return;
+    }
+    
+    // Write length byte if needed
+    if (readOffset == 0) {
+        response.data[0] = _readFileLength;
+        readOffset++;
+        cDataBytes++;
+    }
+    
+    // Write file bytes. Data is a repeating sequence of 0x00, 0x01, .. 0xFF.
+    for (; cDataBytes < sizeof(response.data) && readOffset < _readFileLength; readOffset++, cDataBytes++) {
+        // Subtract one from readOffset to take into account length byte and start file data a 0x00
+        response.data[cDataBytes] = (readOffset - 1) & 0xFF;
+    }
+    
+    // We should always have written something, otherwise there is something wrong with the code above
+    Q_ASSERT(cDataBytes);
+    
+    response.hdr.magic = 'f';
+    response.hdr.session = _sessionId;
+    response.hdr.size = cDataBytes;
+    response.hdr.offset = request->hdr.offset;
+    response.hdr.opcode = QGCUASFileManager::kRspAck;
+    
+    _emitResponse(&response);
+}
+
+/// @brief Handles Terminate commands
+void MockMavlinkFileServer::_terminateCommand(QGCUASFileManager::Request* request)
+{
+    if (request->hdr.session != _sessionId) {
+        _sendNak(QGCUASFileManager::kErrNoSession);
+        return;
+    }
+    
+    _sendAck();
+    
+    // Let our test harness know that we got a terminate command. This is used to validate the a Terminate is correctly
+    // sent after an Open.
+    emit terminateCommandReceived();
+}
+
+/// @brief Handles messages sent to the FTP server.
+void MockMavlinkFileServer::sendMessage(mavlink_message_t message)
+{
+    QGCUASFileManager::Request ackResponse;
+
+    Q_ASSERT(message.msgid == MAVLINK_MSG_ID_ENCAPSULATED_DATA);
+
+    mavlink_encapsulated_data_t requestEncapsulatedData;
+    mavlink_msg_encapsulated_data_decode(&message, &requestEncapsulatedData);
+    QGCUASFileManager::Request* request = (QGCUASFileManager::Request*)&requestEncapsulatedData.data[0];
+    
+    // Validate CRC
+    if (request->hdr.crc32 != QGCUASFileManager::crc32(request)) {
+        _sendNak(QGCUASFileManager::kErrCrc);
+    }
+
+    switch (request->hdr.opcode) {
+        case QGCUASFileManager::kCmdTestNoAck:
+            // ignored, ack not sent back, for testing only
+            break;
+            
+        case QGCUASFileManager::kCmdReset:
+            // terminates all sessions
+            // Fall through to send back Ack
+
+        case QGCUASFileManager::kCmdNone:
+            // ignored, always acked
+            ackResponse.hdr.magic = 'f';
+            ackResponse.hdr.opcode = QGCUASFileManager::kRspAck;
+            ackResponse.hdr.session = 0;
+            ackResponse.hdr.crc32 = 0;
+            ackResponse.hdr.size = 0;
+            _emitResponse(&ackResponse);
+            break;
+
+        case QGCUASFileManager::kCmdList:
+            _listCommand(request);
+            break;
+            
+        case QGCUASFileManager::kCmdOpen:
+            _openCommand(request);
+            break;
+
+        case QGCUASFileManager::kCmdRead:
+            _readCommand(request);
+            break;
+
+        case QGCUASFileManager::kCmdTerminate:
+            _terminateCommand(request);
+            break;
+
+        // Remainder of commands are NYI
+
+        case QGCUASFileManager::kCmdCreate:
+            // creates <path> for writing, returns <session>
+        case QGCUASFileManager::kCmdWrite:
+            // appends <size> bytes at <offset> in <session>
+        case QGCUASFileManager::kCmdRemove:
+            // remove file (only if created by server?)
+        default:
+            // nack for all NYI opcodes
+            _sendNak(QGCUASFileManager::kErrUnknownCommand);
+            break;
+    }
+}
+
+/// @brief Sends an Ack
+void MockMavlinkFileServer::_sendAck(void)
+{
+    QGCUASFileManager::Request ackResponse;
+    
+    ackResponse.hdr.magic = 'f';
+    ackResponse.hdr.opcode = QGCUASFileManager::kRspAck;
+    ackResponse.hdr.session = 0;
+    ackResponse.hdr.size = 0;
+    
+    _emitResponse(&ackResponse);
+}
+
+/// @brief Sends a Nak with the specified error code.
+void MockMavlinkFileServer::_sendNak(QGCUASFileManager::ErrorCode error)
+{
+    QGCUASFileManager::Request nakResponse;
+
+    nakResponse.hdr.magic = 'f';
+    nakResponse.hdr.opcode = QGCUASFileManager::kRspNak;
+    nakResponse.hdr.session = 0;
+    nakResponse.hdr.size = 1;
+    nakResponse.data[0] = error;
+    
+    _emitResponse(&nakResponse);
+}
+
+/// @brief Emits a Request through the messageReceived signal.
+void MockMavlinkFileServer::_emitResponse(QGCUASFileManager::Request* request)
+{
+    mavlink_message_t   mavlinkMessage;
+    
+    request->hdr.crc32 = QGCUASFileManager::crc32(request);
+    
+    mavlink_msg_encapsulated_data_pack(250, 0, &mavlinkMessage, 0 /*_encdata_seq*/, (uint8_t*)request);
+    
+    emit messageReceived(NULL, mavlinkMessage);
+}
\ No newline at end of file

src/qgcunittest/MockMavlinkFileServer.h

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#ifndef MOCKMAVLINKFILESERVER_H
+#define MOCKMAVLINKFILESERVER_H
+
+#include "MockMavlinkInterface.h"
+#include "QGCUASFileManager.h"
+
+/// @file
+///     @brief Mock implementation of Mavlink FTP server. Used as mavlink plugin to MockUAS.
+///             Only root directory access is supported.
+///
+///     @author Don Gagne <don@thegagnes.com>
+
+#include <QStringList>
+
+class MockMavlinkFileServer : public MockMavlinkInterface
+{
+    Q_OBJECT
+    
+public:
+    MockMavlinkFileServer(void);
+    
+    /// @brief Sets the list of files returned by the List command. Prepend names with F or D
+    /// to indicate (F)ile or (D)irectory.
+    void setFileList(QStringList& fileList) { _fileList = fileList; }
+    
+    // From MockMavlinkInterface
+    virtual void sendMessage(mavlink_message_t message);
+    
+    struct FileTestCase {
+        const char* filename;
+        uint8_t     length;
+    };
+    
+    static const size_t cFileTestCases = 3;
+    static const FileTestCase rgFileTestCases[cFileTestCases];
+    
+signals:
+    void terminateCommandReceived(void);
+    
+private:
+    void _sendAck(void);
+    void _sendNak(QGCUASFileManager::ErrorCode error);
+    void _emitResponse(QGCUASFileManager::Request* request);
+    void _listCommand(QGCUASFileManager::Request* request);
+    void _openCommand(QGCUASFileManager::Request* request);
+    void _readCommand(QGCUASFileManager::Request* request);
+    void _terminateCommand(QGCUASFileManager::Request* request);
+    
+    QStringList _fileList;  ///< List of files returned by List command
+    
+    static const uint8_t    _sessionId;
+    uint8_t                 _readFileLength; ///< Length of active file being read
+};
+
+#endif

src/qgcunittest/MockMavlinkInterface.cc

+//
+//  MockMavlinkInterface.cc
+//  QGroundControl
+//
+//  Created by Donald Gagne on 6/19/14.
+//  Copyright (c) 2014 Donald Gagne. All rights reserved.
+//
+
+#include "MockMavlinkInterface.h"

src/qgcunittest/MockMavlinkInterface.h

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#include <QObject>
+
+#include "QGCMAVLink.h"
+#include "LinkInterface.h"
+
+#ifndef MOCKMAVLINKINTERFACE_H
+#define MOCKMAVLINKINTERFACE_H
+
+class MockMavlinkInterface : public QObject
+{
+    Q_OBJECT
+    
+public:
+    virtual void sendMessage(mavlink_message_t message) = 0;
+    
+signals:
+    // link argument will always be NULL
+    void messageReceived(LinkInterface* link, mavlink_message_t message);
+};
+
+#endif

src/qgcunittest/MockUAS.cc

@@ -27,7 +27,8 @@ QString MockUAS::_bogusStaticString;
 
 MockUAS::MockUAS(void) :
     _systemType(MAV_TYPE_QUADROTOR),
-    _systemId(1)
+    _systemId(1),
+    _mavlinkPlugin(NULL)
 {
     
 }
@@ -41,4 +42,13 @@ void MockUAS::setMockParametersAndSignal(MockQGCUASParamManager::ParamMap_t& map
         i.next();
         emit parameterChanged(_systemId, 0, i.key(), i.value());
     }
+}
+
+void MockUAS::sendMessage(mavlink_message_t message)
+{
+    if (!_mavlinkPlugin) {
+        Q_ASSERT(false);
+    }
+    
+    _mavlinkPlugin->sendMessage(message);
 }
\ No newline at end of file

src/qgcunittest/MockUAS.h

@@ -26,6 +26,7 @@
 
 #include "UASInterface.h"
 #include "MockQGCUASParamManager.h"
+#include "MockMavlinkInterface.h"
 
 #include <limits>
 
@@ -50,6 +51,9 @@ public:
     virtual int getUASID(void) const { return _systemId; }
     virtual QGCUASParamManagerInterface* getParamManager() { return &_paramManager; };
     
+    // sendMessage is only supported if a mavlink plugin is installed.
+    virtual void sendMessage(mavlink_message_t message);
+    
 public:
     // MockUAS methods
     MockUAS(void);
@@ -63,12 +67,15 @@ public:
     /// allows you to simulate parameter input and validate parameter setting
     MockQGCUASParamManager* getMockQGCUASParamManager(void) { return &_paramManager; }
     
-    /// Sets the parameter map into the mock QGCUASParamManager and signals parameterChanged for
+    /// @brief Sets the parameter map into the mock QGCUASParamManager and signals parameterChanged for
     /// each param
     void setMockParametersAndSignal(MockQGCUASParamManager::ParamMap_t& map);
     
     void emitRemoteControlChannelRawChanged(int channel, float raw) { emit remoteControlChannelRawChanged(channel, raw); }
     
+    /// @brief Installs a mavlink plugin. Only a single mavlink plugin is supported at a time.
+    void setMockMavlinkPlugin(MockMavlinkInterface* mavlinkPlugin) { _mavlinkPlugin = mavlinkPlugin; };
+    
 public:
     // Unimplemented UASInterface overrides
     virtual QString getUASName() const { Q_ASSERT(false); return _bogusString; };
@@ -109,6 +116,10 @@ public:
     virtual bool systemCanReverse() const { Q_ASSERT(false); return false; };
     virtual QString getSystemTypeName() { Q_ASSERT(false); return _bogusString; };
     virtual int getAutopilotType() { Q_ASSERT(false); return 0; };
+    virtual QGCUASFileManager* getFileManager() {Q_ASSERT(false); return NULL; }
+
+    /** @brief Send a message over this link (to this or to all UAS on this link) */
+    virtual void sendMessage(LinkInterface* link, mavlink_message_t message){ Q_UNUSED(link); Q_UNUSED(message); Q_ASSERT(false); }
     virtual QString getAutopilotTypeName() { Q_ASSERT(false); return _bogusString; };
     virtual void setAutopilotType(int apType) { Q_UNUSED(apType); Q_ASSERT(false); };
     virtual QMap<int, QString> getComponents() { Q_ASSERT(false); return _bogusMapIntQString; };
@@ -176,6 +187,8 @@ private:
     int                 _systemId;
     
     MockQGCUASParamManager _paramManager;
+    
+    MockMavlinkInterface* _mavlinkPlugin;   ///< Mock Mavlink plugin, NULL for none
 
     // Bogus variables used for return types of NYI methods
     QString             _bogusString;

src/qgcunittest/QGCUASFileManagerTest.cc

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#include "QGCUASFileManagerTest.h"
+
+/// @file
+///     @brief QGCUASFileManager unit test. Note: All code here assumes all work between
+///             the unit test, mack mavlink file server and file manager is happening on
+///             the same thread.
+///
+///     @author Don Gagne <don@thegagnes.com>
+
+QGCUASFileManagerUnitTest::QGCUASFileManagerUnitTest(void) :
+    _fileManager(NULL),
+    _multiSpy(NULL)
+{
+    
+}
+
+// Called once before all test cases are run
+void QGCUASFileManagerUnitTest::initTestCase(void)
+{
+    _mockUAS.setMockMavlinkPlugin(&_mockFileServer);
+}
+
+// Called before every test case
+void QGCUASFileManagerUnitTest::init(void)
+{
+    Q_ASSERT(_multiSpy == NULL);
+    
+    _fileManager = new QGCUASFileManager(NULL, &_mockUAS);
+    Q_CHECK_PTR(_fileManager);
+    
+    bool connected = connect(&_mockFileServer, SIGNAL(messageReceived(LinkInterface*, mavlink_message_t)), _fileManager, SLOT(receiveMessage(LinkInterface*, mavlink_message_t)));
+    Q_ASSERT(connected);
+
+    connected = connect(_fileManager, SIGNAL(statusMessage(const QString&)), this, SLOT(statusMessage(const QString&)));
+    Q_ASSERT(connected);
+
+    _rgSignals[statusMessageSignalIndex] = SIGNAL(statusMessage(const QString&));
+    _rgSignals[errorMessageSignalIndex] = SIGNAL(errorMessage(const QString&));
+    _rgSignals[resetStatusMessagesSignalIndex] = SIGNAL(resetStatusMessages(void));
+    
+    _multiSpy = new MultiSignalSpy();
+    Q_CHECK_PTR(_multiSpy);
+    QCOMPARE(_multiSpy->init(_fileManager, _rgSignals, _cSignals), true);
+}
+
+// Called after every test case
+void QGCUASFileManagerUnitTest::cleanup(void)
+{
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_fileManager);
+    
+    delete _fileManager;
+    delete _multiSpy;
+    
+    _fileManager = NULL;
+    _multiSpy = NULL;
+}
+
+/// @brief Connected to QGCUASFileManager statusMessage signal in order to catch list command output
+void QGCUASFileManagerUnitTest::statusMessage(const QString& msg)
+{
+    // Keep a list of all names received so we can test it for correctness
+    _fileListReceived += msg;
+}
+
+
+void QGCUASFileManagerUnitTest::_ackTest(void)
+{
+    Q_ASSERT(_fileManager);
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_multiSpy->checkNoSignals() == true);
+    
+    // If the file manager doesn't receive an ack it will timeout and emit an error. So make sure
+    // we don't get any error signals.
+    QVERIFY(_fileManager->_sendCmdTestAck());
+    QVERIFY(_multiSpy->checkNoSignals());
+}
+
+void QGCUASFileManagerUnitTest::_noAckTest(void)
+{
+    Q_ASSERT(_fileManager);
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_multiSpy->checkNoSignals() == true);
+    
+    // This should not get the ack back and timeout.
+    QVERIFY(_fileManager->_sendCmdTestNoAck());
+    QTest::qWait(2000); // Let the file manager timeout, magic number 2 secs must be larger than file manager ack timeout
+    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask), true);
+}
+
+void QGCUASFileManagerUnitTest::_resetTest(void)
+{
+    Q_ASSERT(_fileManager);
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_multiSpy->checkNoSignals() == true);
+    
+    // Send a reset command
+    //  We should not get any signals back from this
+    QVERIFY(_fileManager->_sendCmdReset());
+    QVERIFY(_multiSpy->checkNoSignals());
+}
+
+void QGCUASFileManagerUnitTest::_listTest(void)
+{
+    Q_ASSERT(_fileManager);
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_multiSpy->checkNoSignals() == true);
+    
+    // Send a bogus path
+    //  We should get a single resetStatusMessages signal
+    //  We should get a single errorMessage signal
+    _fileManager->listDirectory("/bogus");
+    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask | resetStatusMessagesSignalMask), true);
+    _multiSpy->clearAllSignals();
+
+    // Send a list command at the root of the directory tree
+    //  We should get back a single resetStatusMessages signal
+    //  We should not get back an errorMessage signal
+    //  We should get back one or more statusMessage signals
+    //  The returned list should match out inputs
+    
+    QStringList fileList;
+    fileList << "Ddir" << "Ffoo" << "Fbar";
+    _mockFileServer.setFileList(fileList);
+    
+    QStringList fileListExpected;
+    fileListExpected << "dir/" << "foo" << "bar";
+    
+    _fileListReceived.clear();
+    
+    _fileManager->listDirectory("/");
+    QCOMPARE(_multiSpy->checkSignalByMask(resetStatusMessagesSignalMask), true);  // We should be told to reset status messages
+    QCOMPARE(_multiSpy->checkNoSignalByMask(errorMessageSignalMask), true);  // We should not get an error signals
+    QVERIFY(_fileListReceived == fileListExpected);
+}
+
+void QGCUASFileManagerUnitTest::_validateFileContents(const QString& filePath, uint8_t length)
+{
+    QFile file(filePath);
+
+    // Make sure file size is correct
+    QCOMPARE(file.size(), (qint64)length);
+
+    // Read data
+    QVERIFY(file.open(QIODevice::ReadOnly));
+    QByteArray bytes = file.readAll();
+    file.close();
+    
+    // Validate length byte
+    QCOMPARE((uint8_t)bytes[0], length);
+    
+    // Validate file contents:
+    //      Repeating 0x00, 0x01 .. 0xFF until file is full
+    for (uint8_t i=1; i<bytes.length(); i++) {
+        QCOMPARE((uint8_t)bytes[i], (uint8_t)((i-1) & 0xFF));
+    }
+}
+
+void QGCUASFileManagerUnitTest::_openTest(void)
+{
+    Q_ASSERT(_fileManager);
+    Q_ASSERT(_multiSpy);
+    Q_ASSERT(_multiSpy->checkNoSignals() == true);
+    
+    // Send a bogus path
+    //  We should get a single resetStatusMessages signal
+    //  We should get a single errorMessage signal
+    _fileManager->downloadPath("bogus", QDir::temp());
+    QCOMPARE(_multiSpy->checkOnlySignalByMask(errorMessageSignalMask | resetStatusMessagesSignalMask), true);
+    _multiSpy->clearAllSignals();
+    
+    // Clean previous downloads
+    for (size_t i=0; i<MockMavlinkFileServer::cFileTestCases; i++) {
+        QString filePath = QDir::temp().absoluteFilePath(MockMavlinkFileServer::rgFileTestCases[i].filename);
+        if (QFile::exists(filePath)) {
+            Q_ASSERT(QFile::remove(filePath));
+        }
+    }
+
+    // Run through the set of file test cases
+    
+    // We setup a spy on the terminate command signal so that we can determine that a Terminate command was
+    // correctly sent after the Open/Read commands complete.
+    QSignalSpy terminateSpy(&_mockFileServer, SIGNAL(terminateCommandReceived()));
+    
+    for (size_t i=0; i<MockMavlinkFileServer::cFileTestCases; i++) {
+        _fileManager->downloadPath(MockMavlinkFileServer::rgFileTestCases[i].filename, QDir::temp());
+
+        //  We should get a single resetStatusMessages signal
+        //  We should get a single statusMessage signal, which indicated download completion
+        QCOMPARE(_multiSpy->checkOnlySignalByMask(statusMessageSignalMask | resetStatusMessagesSignalMask), true);
+        _multiSpy->clearAllSignals();
+        
+        // We should get a single Terminate command
+        QCOMPARE(terminateSpy.count(), 1);
+        terminateSpy.clear();
+        
+        QString filePath = QDir::temp().absoluteFilePath(MockMavlinkFileServer::rgFileTestCases[i].filename);
+        _validateFileContents(filePath, MockMavlinkFileServer::rgFileTestCases[i].length);
+    }
+}

src/qgcunittest/QGCUASFileManagerTest.h

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#ifndef QGCUASFILEMANAGERTEST_H
+#define QGCUASFILEMANAGERTEST_H
+
+#include <QObject>
+#include <QtTest/QtTest>
+
+#include "AutoTest.h"
+#include "MockUAS.h"
+#include "MockMavlinkFileServer.h"
+#include "QGCUASFileManager.h"
+#include "MultiSignalSpy.h"
+
+/// @file
+///     @brief QGCUASFileManager unit test
+///
+///     @author Don Gagne <don@thegagnes.com>
+
+class QGCUASFileManagerUnitTest : public QObject
+{
+    Q_OBJECT
+    
+public:
+    QGCUASFileManagerUnitTest(void);
+    
+private slots:
+    // Test case initialization
+    void initTestCase(void);
+    void init(void);
+    void cleanup(void);
+    
+    // Test cases
+    void _ackTest(void);
+    void _noAckTest(void);
+    void _resetTest(void);
+    void _listTest(void);
+    void _openTest(void);
+    
+    // Connected to QGCUASFileManager statusMessage signal
+    void statusMessage(const QString&);
+    
+private:
+    void _validateFileContents(const QString& filePath, uint8_t length);
+
+    enum {
+        statusMessageSignalIndex = 0,
+        errorMessageSignalIndex,
+        resetStatusMessagesSignalIndex,
+
+        maxSignalIndex
+    };
+    
+    enum {
+        statusMessageSignalMask =           1 << statusMessageSignalIndex,
+        errorMessageSignalMask =            1 << errorMessageSignalIndex,
+        resetStatusMessagesSignalMask =     1 << resetStatusMessagesSignalIndex,
+    };
+    
+    MockUAS                 _mockUAS;
+    MockMavlinkFileServer   _mockFileServer;
+    
+    QGCUASFileManager*  _fileManager;
+
+    MultiSignalSpy*     _multiSpy;
+    static const size_t _cSignals = maxSignalIndex;
+    const char*         _rgSignals[_cSignals];
+    
+    QStringList _fileListReceived;
+};
+
+DECLARE_TEST(QGCUASFileManagerUnitTest)
+
+#endif

src/uas/QGCMAVLinkUASFactory.cc

@@ -35,6 +35,7 @@ UASInterface* QGCMAVLinkUASFactory::createUAS(MAVLinkProtocol* mavlink, LinkInte
 
         // Connect this robot to the UAS object
         connect(mavlink, SIGNAL(messageReceived(LinkInterface*, mavlink_message_t)), mav, SLOT(receiveMessage(LinkInterface*, mavlink_message_t)));
+        connect(mavlink, SIGNAL(messageReceived(LinkInterface*,mavlink_message_t)), mav->getFileManager(), SLOT(receiveMessage(LinkInterface*, mavlink_message_t)));
 #ifdef QGC_PROTOBUF_ENABLED
         connect(mavlink, SIGNAL(extendedMessageReceived(LinkInterface*, std::tr1::shared_ptr<google::protobuf::Message>)), mav, SLOT(receiveExtendedMessage(LinkInterface*, std::tr1::shared_ptr<google::protobuf::Message>)));
 #endif

src/uas/QGCUASFileManager.h

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#ifndef QGCUASFILEMANAGER_H
+#define QGCUASFILEMANAGER_H
+
+#include <QObject>
+#include <QDir>
+
+#include "UASInterface.h"
+
+class QGCUASFileManager : public QObject
+{
+    Q_OBJECT
+public:
+    QGCUASFileManager(QObject* parent, UASInterface* uas);
+    
+    /// These methods are only used for testing purposes.
+    bool _sendCmdTestAck(void) { return _sendOpcodeOnlyCmd(kCmdNone, kCOAck); };
+    bool _sendCmdTestNoAck(void) { return _sendOpcodeOnlyCmd(kCmdTestNoAck, kCOAck); };
+    bool _sendCmdReset(void) { return _sendOpcodeOnlyCmd(kCmdReset, kCOAck); };
+
+signals:
+    void statusMessage(const QString& msg);
+    void resetStatusMessages();
+    void errorMessage(const QString& msg);
+    void listComplete(void);
+
+public slots:
+    void receiveMessage(LinkInterface* link, mavlink_message_t message);
+    void listDirectory(const QString& dirPath);
+    void downloadPath(const QString& from, const QDir& downloadDir);
+
+protected:
+    struct RequestHeader
+        {
+            uint8_t		magic;      ///> Magic byte 'f' to idenitfy FTP protocol
+            uint8_t		session;    ///> Session id for read and write commands
+            uint8_t		opcode;     ///> Command opcode
+            uint8_t		size;       ///> Size of data
+            uint32_t	crc32;      ///> CRC for entire Request structure, with crc32 set to 0
+            uint32_t	offset;     ///> Offsets for List and Read commands
+        };
+
+    struct Request
+    {
+        struct RequestHeader hdr;
+        // The entire Request must fit into the data member of the mavlink_encapsulated_data_t structure. We use as many leftover bytes
+        // after we use up space for the RequestHeader for the data portion of the Request.
+        uint8_t data[sizeof(((mavlink_encapsulated_data_t*)0)->data) - sizeof(RequestHeader)];
+    };
+
+    enum Opcode
+        {
+            // Commands
+            kCmdNone,       ///> ignored, always acked
+            kCmdTerminate,	///> releases sessionID, closes file
+            kCmdReset,      ///> terminates all sessions
+            kCmdList,       ///> list files in <path> from <offset>
+            kCmdOpen,       ///> opens <path> for reading, returns <session>
+            kCmdRead,       ///> reads <size> bytes from <offset> in <session>
+            kCmdCreate,     ///> creates <path> for writing, returns <session>
+            kCmdWrite,      ///> appends <size> bytes at <offset> in <session>
+            kCmdRemove,     ///> remove file (only if created by server?)
+
+            // Responses
+            kRspAck,        ///> positive acknowledgement of previous command
+            kRspNak,        ///> negative acknowledgement of previous command
+            
+            // Used for testing only, not part of protocol
+            kCmdTestNoAck,  // ignored, ack not sent back, should timeout waiting for ack
+        };
+
+    enum ErrorCode
+        {
+            kErrNone,
+            kErrNoRequest,
+            kErrNoSession,
+            kErrSequence,
+            kErrNotDir,
+            kErrNotFile,
+            kErrEOF,
+            kErrNotAppend,
+            kErrTooBig,
+            kErrIO,
+            kErrPerm,
+            kErrUnknownCommand,
+            kErrCrc
+        };
+
+
+    enum OperationState
+        {
+            kCOIdle,    // not doing anything
+            kCOAck,     // waiting for an Ack
+            kCOList,    // waiting for List response
+            kCOOpen,    // waiting for Open response
+            kCORead,    // waiting for Read response
+        };
+    
+    
+protected slots:
+    void _ackTimeout(void);
+    
+protected:
+    bool _sendOpcodeOnlyCmd(uint8_t opcode, OperationState newOpState);
+    void _setupAckTimeout(void);
+    void _clearAckTimeout(void);
+    void _emitErrorMessage(const QString& msg);
+    void _emitStatusMessage(const QString& msg);
+    void _sendRequest(Request* request);
+    void _fillRequestWithString(Request* request, const QString& str);
+    void _openAckResponse(Request* openAck);
+    void _readAckResponse(Request* readAck);
+    void _listAckResponse(Request* listAck);
+    void _sendListCommand(void);
+    void _sendTerminateCommand(void);
+    void _closeReadSession(bool success);
+    
+    static quint32 crc32(Request* request, unsigned state = 0);
+    static QString errorString(uint8_t errorCode);
+
+    OperationState      _currentOperation;              ///> Current operation of state machine
+    QTimer              _ackTimer;                      ///> Used to signal a timeout waiting for an ack
+    static const int    _ackTimerTimeoutMsecs = 1000;   ///> Timeout in msecs for ack timer
+    
+    UASInterface* _mav;
+    quint16 _encdata_seq;
+
+    unsigned    _listOffset;    ///> offset for the current List operation
+    QString     _listPath;      ///> path for the current List operation
+    
+    uint8_t     _activeSession;             ///> currently active session, 0 for none
+    uint32_t    _readOffset;                ///> current read offset
+    QByteArray  _readFileAccumulator;       ///> Holds file being downloaded
+    QDir        _readFileDownloadDir;       ///> Directory to download file to
+    QString     _readFileDownloadFilename;  ///> Filename (no path) for download file
+    
+    // We give MockMavlinkFileServer friend access so that it can use the data structures and opcodes
+    // to build a mock mavlink file server for testing.
+    friend class MockMavlinkFileServer;
+};
+
+#endif // QGCUASFILEMANAGER_H

src/uas/UAS.cc

@@ -139,6 +139,7 @@ UAS::UAS(MAVLinkProtocol* protocol, QThread* thread, int id) : UASInterface(),
     airSpeed(std::numeric_limits<double>::quiet_NaN()),
     groundSpeed(std::numeric_limits<double>::quiet_NaN()),
     waypointManager(this),
+    fileManager(this, this),
 
     attitudeKnown(false),
     attitudeStamped(false),
@@ -148,6 +149,8 @@ UAS::UAS(MAVLinkProtocol* protocol, QThread* thread, int id) : UASInterface(),
     pitch(0.0),
     yaw(0.0),
 
+    imagePackets(0),    // We must initialize to 0, otherwise extended data packets maybe incorrectly thought to be images
+
     blockHomePositionChanges(false),
     receivedMode(false),
 
@@ -175,6 +178,8 @@ UAS::UAS(MAVLinkProtocol* protocol, QThread* thread, int id) : UASInterface(),
         componentMulti[i] = false;
     }
 
+    connect(mavlink, SIGNAL(messageReceived(LinkInterface*,mavlink_message_t)), &fileManager, SLOT(receiveMessage(LinkInterface*,mavlink_message_t)));
+
     // Store a list of available actions for this UAS.
     // Basically everything exposed as a SLOT with no return value or arguments.
 
@@ -1368,6 +1373,7 @@ void UAS::receiveMessage(LinkInterface* link, mavlink_message_t message)
                 // NO VALID TRANSACTION - ABORT
                 // Restart statemachine
                 imagePacketsArrived = 0;
+                break;
             }
 
             for (int i = 0; i < imagePayload; ++i)
@@ -1384,6 +1390,8 @@ void UAS::receiveMessage(LinkInterface* link, mavlink_message_t message)
             if ((imagePacketsArrived >= imagePackets))
             {
                 // Restart statemachine
+                imagePackets = 0;
+                imagePacketsArrived = 0;
                 emit imageReady(this);
                 //qDebug() << "imageReady emitted. all packets arrived";
             }

src/uas/UAS.h

@@ -42,6 +42,7 @@ This file is part of the QGROUNDCONTROL project
 #include "QGCJSBSimLink.h"
 #include "QGCXPlaneLink.h"
 #include "QGCUASParamManager.h"
+#include "QGCUASFileManager.h"
 
 
 /**
@@ -370,6 +371,7 @@ public:
 #endif
 
     friend class UASWaypointManager;
+    friend class QGCUASFileManager;
 
 protected: //COMMENTS FOR TEST UNIT
     /// LINK ID AND STATUS
@@ -472,6 +474,7 @@ protected: //COMMENTS FOR TEST UNIT
     double groundSpeed;          ///< Groundspeed
     double bearingToWaypoint;    ///< Bearing to next waypoint
     UASWaypointManager waypointManager;
+    QGCUASFileManager   fileManager;
 
     /// ATTITUDE
     bool attitudeKnown;             ///< True if attitude was received, false else
@@ -554,6 +557,10 @@ public:
         return &paramMgr;
     }
 
+    virtual QGCUASFileManager* getFileManager() {
+        return &fileManager;
+    }
+
     /** @brief Get the HIL simulation */
     QGCHilLink* getHILSimulation() const {
         return simulation;

src/uas/UASInterface.h

@@ -52,6 +52,8 @@ This file is part of the QGROUNDCONTROL project
 #endif
 #endif
 
+class QGCUASFileManager;
+
 enum BatteryType
 {
     NICD = 0,
@@ -158,6 +160,13 @@ public:
     /** @brief Get reference to the param manager **/
     virtual QGCUASParamManagerInterface* getParamManager() = 0;
 
+    virtual QGCUASFileManager* getFileManager() = 0;
+
+    /** @brief Send a message over this link (to this or to all UAS on this link) */
+    virtual void sendMessage(LinkInterface* link, mavlink_message_t message) = 0;
+    /** @brief Send a message over all links this UAS can be reached with (!= all links) */
+    virtual void sendMessage(mavlink_message_t message) = 0;
+
     /* COMMUNICATION FLAGS */
 
     enum CommStatus {

src/ui/MainWindow.cc

@@ -71,6 +71,7 @@ This file is part of the QGROUNDCONTROL project
 #include "SerialSettingsDialog.h"
 #include "terminalconsole.h"
 #include "menuactionhelper.h"
+#include "QGCUASFileViewMulti.h"
 #include <QDesktopWidget>
 
 // Add support for the MAVLink generator UI if it's been requested.
@@ -657,6 +658,7 @@ void MainWindow::buildCommonWidgets()
     createDockWidget(engineeringView,new QGCMAVLinkInspector(mavlink,this),tr("MAVLink Inspector"),"MAVLINK_INSPECTOR_DOCKWIDGET",VIEW_ENGINEER,Qt::RightDockWidgetArea);
 
     createDockWidget(engineeringView,new ParameterInterface(this),tr("Onboard Parameters"),"PARAMETER_INTERFACE_DOCKWIDGET",VIEW_ENGINEER,Qt::RightDockWidgetArea);
+    createDockWidget(engineeringView,new QGCUASFileViewMulti(this),tr("Onboard Files"),"FILE_VIEW_DOCKWIDGET",VIEW_ENGINEER,Qt::RightDockWidgetArea);
     createDockWidget(simView,new ParameterInterface(this),tr("Onboard Parameters"),"PARAMETER_INTERFACE_DOCKWIDGET",VIEW_SIMULATION,Qt::RightDockWidgetArea);
 
     menuActionHelper->createToolAction(tr("Map View"), "MAP_VIEW_DOCKWIDGET");
@@ -818,6 +820,10 @@ void MainWindow::loadDockWidget(const QString& name)
     {
         createDockWidget(centerStack->currentWidget(),new ParameterInterface(this),tr("Onboard Parameters"),"PARAMETER_INTERFACE_DOCKWIDGET",currentView,Qt::RightDockWidgetArea);
     }
+    else if (name == "FILE_VIEW_DOCKWIDGET")
+    {
+        createDockWidget(centerStack->currentWidget(),new QGCUASFileViewMulti(this),tr("Onboard Files"),"FILE_VIEW_DOCKWIDGET",VIEW_ENGINEER,Qt::RightDockWidgetArea);
+    }
     else if (name == "UAS_STATUS_DETAILS_DOCKWIDGET")
     {
         createDockWidget(centerStack->currentWidget(),new UASInfoWidget(this),tr("Status Details"),"UAS_STATUS_DETAILS_DOCKWIDGET",currentView,Qt::RightDockWidgetArea);

src/ui/MainWindow.h

@@ -76,6 +76,7 @@ This file is part of the QGROUNDCONTROL project
 #include "QGCMAVLinkLogPlayer.h"
 #include "QGCVehicleConfig.h"
 #include "MAVLinkDecoder.h"
+#include "QGCUASFileViewMulti.h"
 
 class QGCMapTool;
 class QGCMAVLinkMessageSender;
@@ -86,6 +87,7 @@ class Linecharts;
 class QGCDataPlot2D;
 class JoystickWidget;
 class MenuActionHelper;
+class QGCUASFileViewMulti;
 
 /**
  * @brief Main Application Window
@@ -476,6 +478,8 @@ protected:
     QGCMAVLinkLogPlayer* logPlayer;
     QMap<int, QDockWidget*> hilDocks;
 
+    QPointer<QGCUASFileViewMulti> fileWidget;
+
     // Popup widgets
     JoystickWidget* joystickWidget;
 

src/ui/QGCHilXPlaneConfiguration.cc

@@ -50,6 +50,10 @@ void QGCHilXPlaneConfiguration::setVersion(int version)
 
 void QGCHilXPlaneConfiguration::toggleSimulation(bool connect)
 {
+    if (!link) {
+        return;
+    }
+
     Q_UNUSED(connect);
     if (!link->isConnected())
     {

src/ui/QGCUASFileView.cc

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#include "QGCUASFileView.h"
+#include "uas/QGCUASFileManager.h"
+
+#include <QFileDialog>
+#include <QDir>
+#include <QMessageBox>
+
+QGCUASFileView::QGCUASFileView(QWidget *parent, QGCUASFileManager *manager) :
+    QWidget(parent),
+    _manager(manager)
+{
+    _ui.setupUi(this);
+
+    bool success = connect(_ui.listFilesButton, SIGNAL(clicked()), this, SLOT(_refreshTree()));
+    Q_ASSERT(success);
+    success = connect(_ui.downloadButton, SIGNAL(clicked()), this, SLOT(_downloadFiles()));
+    Q_ASSERT(success);
+    success = connect(_ui.treeWidget, SIGNAL(currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)), this, SLOT(_currentItemChanged(QTreeWidgetItem*, QTreeWidgetItem*)));
+    Q_ASSERT(success);
+    Q_UNUSED(success);
+}
+
+void QGCUASFileView::_downloadFiles(void)
+{
+    QString dir = QFileDialog::getExistingDirectory(this, tr("Download Directory"),
+                                                     QDir::homePath(),
+                                                     QFileDialog::ShowDirsOnly
+                                                     | QFileDialog::DontResolveSymlinks);
+    // And now download to this location
+    QString path;
+    QTreeWidgetItem* item = _ui.treeWidget->currentItem();
+    if (item && item->type() == _typeFile) {
+        do {
+            path.prepend("/" + item->text(0));
+            item = item->parent();
+        } while (item);
+        qDebug() << "Download: " << path;
+        
+        bool success = connect(_manager, SIGNAL(statusMessage(QString)), this, SLOT(_downloadStatusMessage(QString)));
+        Q_ASSERT(success);
+        success = connect(_manager, SIGNAL(errorMessage(QString)), this, SLOT(_downloadStatusMessage(QString)));
+        Q_ASSERT(success);
+        Q_UNUSED(success);
+        _manager->downloadPath(path, QDir(dir));
+    }
+}
+
+void QGCUASFileView::_refreshTree(void)
+{
+    QTreeWidgetItem* item;
+    
+    for (int i=_ui.treeWidget->invisibleRootItem()->childCount(); i>=0; i--) {
+        item = _ui.treeWidget->takeTopLevelItem(i);
+        delete item;
+    }
+
+    _walkIndexStack.clear();
+    _walkItemStack.clear();
+    _walkIndexStack.append(0);
+    _walkItemStack.append(_ui.treeWidget->invisibleRootItem());
+    
+    bool success = connect(_manager, SIGNAL(statusMessage(QString)), this, SLOT(_treeStatusMessage(QString)));
+    Q_ASSERT(success);
+    success = connect(_manager, SIGNAL(errorMessage(QString)), this, SLOT(_treeErrorMessage(QString)));
+    Q_ASSERT(success);
+    success = connect(_manager, SIGNAL(listComplete(void)), this, SLOT(_listComplete(void)));
+    Q_ASSERT(success);
+    Q_UNUSED(success);
+
+    qDebug() << "List: /";
+    _manager->listDirectory("/");
+}
+
+void QGCUASFileView::_treeStatusMessage(const QString& msg)
+{
+    int type;
+    if (msg.startsWith("F")) {
+        type = _typeFile;
+    } else if (msg.startsWith("D")) {
+        type = _typeDir;
+        if (msg == "D." || msg == "D..") {
+            return;
+        }
+    } else {
+        Q_ASSERT(false);
+    }
+
+    QTreeWidgetItem* item;
+    if (_walkItemStack.count() == 0) {
+        item = new QTreeWidgetItem(_ui.treeWidget, type);
+    } else {
+        item = new QTreeWidgetItem(_walkItemStack.last(), type);
+    }
+    Q_CHECK_PTR(item);
+    
+    item->setText(0, msg.right(msg.size() - 1));
+}
+
+void QGCUASFileView::_treeErrorMessage(const QString& msg)
+{
+    QTreeWidgetItem* item;
+    if (_walkItemStack.count() == 0) {
+        item = new QTreeWidgetItem(_ui.treeWidget, _typeError);
+    } else {
+        item = new QTreeWidgetItem(_walkItemStack.last(), _typeError);
+    }
+    Q_CHECK_PTR(item);
+    
+    item->setText(0, tr("Error: ") + msg);
+}
+
+void QGCUASFileView::_listComplete(void)
+{
+    // Walk the current items, traversing down into directories
+    
+Again:
+    int walkIndex = _walkIndexStack.last();
+    QTreeWidgetItem* parentItem = _walkItemStack.last();
+    QTreeWidgetItem* childItem = parentItem->child(walkIndex);
+
+    // Loop until we hit a directory
+    while (childItem && childItem->type() != _typeDir) {
+        // Move to next index at current level
+        _walkIndexStack.last() = ++walkIndex;
+        childItem = parentItem->child(walkIndex);
+    }
+    
+    if (childItem) {
+        // Process this item
+        QString text = childItem->text(0);
+        
+        // Move to the next item for processing at this level
+        _walkIndexStack.last() = ++walkIndex;
+        
+        // Push this new directory on the stack
+        _walkItemStack.append(childItem);
+        _walkIndexStack.append(0);
+        
+        // Ask for the directory list
+        QString dir;
+        for (int i=1; i<_walkItemStack.count(); i++) {
+            QTreeWidgetItem* item = _walkItemStack[i];
+            dir.append("/" + item->text(0));
+        }
+        qDebug() << "List:" << dir;
+        _manager->listDirectory(dir);
+    } else {
+        // We have run out of items at the this level, pop the stack and keep going at that level
+        _walkIndexStack.removeLast();
+        _walkItemStack.removeLast();
+        if (_walkIndexStack.count() != 0) {
+            goto Again;
+        } else {
+            disconnect(_manager, SIGNAL(statusMessage(QString)), this, SLOT(_treeStatusMessage(QString)));
+            disconnect(_manager, SIGNAL(errorMessage(QString)), this, SLOT(_treeErrorMessage(QString)));
+            disconnect(_manager, SIGNAL(listComplete(void)), this, SLOT(_listComplete(void)));
+        }
+    }
+}
+
+void QGCUASFileView::_downloadStatusMessage(const QString& msg)
+{
+    disconnect(_manager, SIGNAL(statusMessage(QString)), this, SLOT(_downloadStatusMessage(QString)));
+    disconnect(_manager, SIGNAL(errorMessage(QString)), this, SLOT(_downloadStatusMessage(QString)));
+    
+    QMessageBox msgBox;
+    msgBox.setWindowModality(Qt::ApplicationModal);
+    msgBox.setText(msg);
+    msgBox.exec();
+}
+
+void QGCUASFileView::_currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous)
+{
+    Q_UNUSED(previous);
+    _ui.downloadButton->setEnabled(current->type() == _typeFile);
+}

src/ui/QGCUASFileView.h

+/*=====================================================================
+ 
+ QGroundControl Open Source Ground Control Station
+ 
+ (c) 2009 - 2014 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
+ 
+ This file is part of the QGROUNDCONTROL project
+ 
+ QGROUNDCONTROL is free software: you can redistribute it and/or modify
+ it under the terms of the GNU General Public License as published by
+ the Free Software Foundation, either version 3 of the License, or
+ (at your option) any later version.
+ 
+ QGROUNDCONTROL is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ GNU General Public License for more details.
+ 
+ You should have received a copy of the GNU General Public License
+ along with QGROUNDCONTROL. If not, see <http://www.gnu.org/licenses/>.
+ 
+ ======================================================================*/
+
+#ifndef QGCUASFILEVIEW_H
+#define QGCUASFILEVIEW_H
+
+#include <QWidget>
+#include <QTreeWidgetItem>
+
+#include "uas/QGCUASFileManager.h"
+#include "ui_QGCUASFileView.h"
+
+class QGCUASFileView : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit QGCUASFileView(QWidget *parent, QGCUASFileManager *manager);
+
+protected:
+    QGCUASFileManager* _manager;
+    
+private slots:
+    void _refreshTree(void);
+    void _downloadFiles(void);
+    void _treeStatusMessage(const QString& msg);
+    void _treeErrorMessage(const QString& msg);
+    void _listComplete(void);
+    void _downloadStatusMessage(const QString& msg);
+    void _currentItemChanged(QTreeWidgetItem* current, QTreeWidgetItem* previous);
+
+private:
+    static const int        _typeFile = QTreeWidgetItem::UserType + 1;
+    static const int        _typeDir = QTreeWidgetItem::UserType + 2;
+    static const int        _typeError = QTreeWidgetItem::UserType + 3;
+    
+    QList<int>              _walkIndexStack;
+    QList<QTreeWidgetItem*> _walkItemStack;
+    Ui::QGCUASFileView      _ui;
+};
+
+#endif // QGCUASFILEVIEW_H

src/ui/QGCUASFileView.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QGCUASFileView</class>
+ <widget class="QWidget" name="QGCUASFileView">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>414</width>
+    <height>518</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QGridLayout" name="gridLayout">
+   <item row="1" column="1">
+    <widget class="QPushButton" name="listFilesButton">
+     <property name="text">
+      <string>List Files</string>
+     </property>
+    </widget>
+   </item>
+   <item row="0" column="0" colspan="3">
+    <widget class="QTreeWidget" name="treeWidget">
+     <property name="headerHidden">
+      <bool>true</bool>
+     </property>
+     <column>
+      <property name="text">
+       <string notr="true">1</string>
+      </property>
+     </column>
+    </widget>
+   </item>
+   <item row="1" column="2">
+    <widget class="QPushButton" name="downloadButton">
+     <property name="enabled">
+      <bool>false</bool>
+     </property>
+     <property name="text">
+      <string>Download File</string>
+     </property>
+    </widget>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>

src/ui/QGCUASFileViewMulti.cc

+#include "QGCUASFileViewMulti.h"
+#include "ui_QGCUASFileViewMulti.h"
+#include "UASInterface.h"
+#include "UASManager.h"
+#include "QGCUASFileView.h"
+
+QGCUASFileViewMulti::QGCUASFileViewMulti(QWidget *parent) :
+    QWidget(parent),
+    ui(new Ui::QGCUASFileViewMulti)
+{
+    ui->setupUi(this);
+    setMinimumSize(600, 80);
+    connect(UASManager::instance(), SIGNAL(UASCreated(UASInterface*)), this, SLOT(systemCreated(UASInterface*)));
+    connect(UASManager::instance(), SIGNAL(activeUASSet(int)), this, SLOT(systemSetActive(int)));
+
+    if (UASManager::instance()->getActiveUAS()) {
+        systemCreated(UASManager::instance()->getActiveUAS());
+        systemSetActive(UASManager::instance()->getActiveUAS()->getUASID());
+    }
+
+}
+
+void QGCUASFileViewMulti::systemDeleted(QObject* uas)
+{
+    UASInterface* mav = dynamic_cast<UASInterface*>(uas);
+    if (mav)
+    {
+        int id = mav->getUASID();
+        QGCUASFileView* list = lists.value(id, NULL);
+        if (list)
+        {
+            delete list;
+            lists.remove(id);
+        }
+    }
+}
+
+void QGCUASFileViewMulti::systemCreated(UASInterface* uas)
+{
+    if (!uas) {
+        return;
+    }
+
+    QGCUASFileView* list = new QGCUASFileView(ui->stackedWidget, uas->getFileManager());
+    lists.insert(uas->getUASID(), list);
+    ui->stackedWidget->addWidget(list);
+    // Ensure widget is deleted when system is deleted
+    connect(uas, SIGNAL(destroyed(QObject*)), this, SLOT(systemDeleted(QObject*)));
+}
+
+void QGCUASFileViewMulti::systemSetActive(int uas)
+{
+    QGCUASFileView* list = lists.value(uas, NULL);
+    if (list) {
+        ui->stackedWidget->setCurrentWidget(list);
+    }
+}
+
+QGCUASFileViewMulti::~QGCUASFileViewMulti()
+{
+    delete ui;
+}
+
+void QGCUASFileViewMulti::changeEvent(QEvent *e)
+{
+    QWidget::changeEvent(e);
+    switch (e->type()) {
+    case QEvent::LanguageChange:
+        ui->retranslateUi(this);
+        break;
+    default:
+        break;
+    }
+}

src/ui/QGCUASFileViewMulti.h

+#ifndef QGCUASFILEVIEWMULTI_H
+#define QGCUASFILEVIEWMULTI_H
+
+#include <QWidget>
+#include <QMap>
+
+#include "QGCUASFileView.h"
+#include "UASInterface.h"
+
+namespace Ui
+{
+class QGCUASFileViewMulti;
+}
+
+class QGCUASFileViewMulti : public QWidget
+{
+    Q_OBJECT
+
+public:
+    explicit QGCUASFileViewMulti(QWidget *parent = 0);
+    ~QGCUASFileViewMulti();
+
+public slots:
+    void systemDeleted(QObject* uas);
+    void systemCreated(UASInterface* uas);
+    void systemSetActive(int uas);
+
+protected:
+    void changeEvent(QEvent *e);
+    QMap<int, QGCUASFileView*> lists;
+
+private:
+    Ui::QGCUASFileViewMulti *ui;
+};
+
+#endif // QGCUASFILEVIEWMULTI_H

src/ui/QGCUASFileViewMulti.ui

+<?xml version="1.0" encoding="UTF-8"?>
+<ui version="4.0">
+ <class>QGCUASFileViewMulti</class>
+ <widget class="QWidget" name="QGCUASFileViewMulti">
+  <property name="geometry">
+   <rect>
+    <x>0</x>
+    <y>0</y>
+    <width>400</width>
+    <height>300</height>
+   </rect>
+  </property>
+  <property name="windowTitle">
+   <string>Form</string>
+  </property>
+  <layout class="QHBoxLayout" name="horizontalLayout">
+   <property name="margin">
+    <number>0</number>
+   </property>
+   <item>
+    <widget class="QStackedWidget" name="stackedWidget"/>
+   </item>
+  </layout>
+ </widget>
+ <resources/>
+ <connections/>
+</ui>