Bootloader.h 7.72 KB
Newer Older
1 2 3 4 5 6 7 8 9
/****************************************************************************
 *
 *   (c) 2009-2016 QGROUNDCONTROL PROJECT <http://www.qgroundcontrol.org>
 *
 * QGroundControl is licensed according to the terms in the file
 * COPYING.md in the root of the source code directory.
 *
 ****************************************************************************/

10 11 12 13 14 15 16 17 18

/// @file
///     @author Don Gagne <don@thegagnes.com>

#ifndef Bootloader_H
#define Bootloader_H

#include "FirmwareImage.h"

19
#include <QSerialPort>
20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35

#include <stdint.h>

/// Bootloader Utility routines. Works with PX4 bootloader and 3DR Radio bootloader.
class Bootloader : public QObject
{
    Q_OBJECT
    
public:
    explicit Bootloader(QObject *parent = 0);
    
    /// @brief Returns the error message associated with the last failed call to one of the bootloader
    ///         utility routine below.
    QString errorString(void) { return _errorString; }
    
    /// @brief Opens a port to the bootloader
36
    bool open(QSerialPort* port, const QString portName);
37 38 39
    
    /// @brief Read a PROTO_SYNC response from the bootloader
    /// @return true: Valid sync response was received
40
    bool sync(QSerialPort* port);
41 42
    
    /// @brief Erases the current program
43
    bool erase(QSerialPort* port);
44 45
    
    /// @brief Program the board with the specified image
46
    bool program(QSerialPort* port, const FirmwareImage* image);
47 48
    
    /// @brief Verify the board flash.
49
    bool verify(QSerialPort* port, const FirmwareImage* image);
50 51 52 53 54
    
    /// @brief Retrieve a set of board info from the bootloader of PX4 FMU and PX4 Flow boards
    ///     @param bootloaderVersion Returned INFO_BL_REV
    ///     @param boardID Returned INFO_BOARD_ID
    ///     @param flashSize Returned INFO_FLASH_SIZE
55
    bool getPX4BoardInfo(QSerialPort* port, uint32_t& bootloaderVersion, uint32_t& boardID, uint32_t& flashSize);
56 57
    
    /// @brief Retrieve the board id from a 3DR Radio
58
    bool get3DRRadioBoardId(QSerialPort* port, uint32_t& boardID);
59 60
    
    /// @brief Sends a PROTO_REBOOT command to the bootloader
61
    bool reboot(QSerialPort* port);
62 63
    
    // Supported bootloader board ids
64 65 66
    static const int boardIDPX4FMUV1 = 5;       ///< PX4 V1 board, as from USB PID
    static const int boardIDPX4FMUV2 = 9;       ///< PX4 V2 board, as from USB PID
    static const int boardIDPX4FMUV4 = 11;      ///< PX4 V4 board, as from USB PID
67 68
    static const int boardIDPX4FMUV4PRO = 13;      ///< PX4 V4PRO board, as from USB PID
    static const int boardIDPX4FMUV5 = 50;      ///< PX4 V5 board, as from USB PID
69 70
    static const int boardIDPX4Flow = 6;        ///< PX4 Flow board, as from USB PID
    static const int boardIDAeroCore = 98;      ///< Gumstix AeroCore board, as from USB PID
71
    static const int boardIDAUAVX2_1 = 33;      ///< AUAV X2.1 board, as from USB PID
72 73 74 75
    static const int boardID3DRRadio = 78;      ///< 3DR Radio. This is an arbitrary value unrelated to the PID
    static const int boardIDMINDPXFMUV2 = 88;   ///< MindPX V2 board, as from USB PID
    static const int boardIDTAPV1 = 64;         ///< TAP V1 board, as from USB PID
    static const int boardIDASCV1 = 65;         ///< ASC V1 board, as from USB PID
76
    static const int boardIDCrazyflie2 = 12;    ///< Crazyflie 2.0 board, as from USB PID
DonLakeFlyer's avatar
DonLakeFlyer committed
77 78 79 80 81

    /// Simulated board id for V3 which is a V2 board which supports larger flash space
    /// IMPORTANT: Make sure this id does not conflict with any newly added real board ids
    static const int boardIDPX4FMUV3 = 255;

82 83 84 85 86
signals:
    /// @brief Signals progress indicator for long running bootloader utility routines
    void updateProgress(int curr, int total);
    
private:
87 88
    bool _binProgram(QSerialPort* port, const FirmwareImage* image);
    bool _ihxProgram(QSerialPort* port, const FirmwareImage* image);
89
    
90 91
    bool _write(QSerialPort* port, const uint8_t* data, qint64 maxSize);
    bool _write(QSerialPort* port, const uint8_t byte);
92
    
93
    bool _read(QSerialPort* port, uint8_t* data, qint64 maxSize, int readTimeout = _readTimout);
94
    
95 96
    bool _sendCommand(QSerialPort* port, uint8_t cmd, int responseTimeout = _responseTimeout);
    bool _getCommandResponse(QSerialPort* port, const int responseTimeout = _responseTimeout);
97
    
98
    bool _getPX4BoardInfo(QSerialPort* port, uint8_t param, uint32_t& value);
99
    
100 101 102 103
    bool _verifyBytes(QSerialPort* port, const FirmwareImage* image);
    bool _binVerifyBytes(QSerialPort* port, const FirmwareImage* image);
    bool _ihxVerifyBytes(QSerialPort* port, const FirmwareImage* image);
    bool _verifyCRC(QSerialPort* port);
104 105 106 107

    enum {
        // protocol bytes
        PROTO_INSYNC =          0x12,   ///< 'in sync' byte sent before status
108
        PROTO_BAD_SILICON_REV = 0x14,   ///< device is using silicon not suitable for the target the bootloader was used for
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130
        PROTO_EOC =             0x20,   ///< end of command
        
        // Reply bytes
        PROTO_OK =              0x10,   ///< INSYNC/OK      - 'ok' response
        PROTO_FAILED =          0x11,   ///< INSYNC/FAILED  - 'fail' response
        PROTO_INVALID =         0x13,	///< INSYNC/INVALID - 'invalid' response for bad commands
        
        // Command bytes
        PROTO_GET_SYNC =        0x21,   ///< NOP for re-establishing sync
        PROTO_GET_DEVICE =      0x22,   ///< get device ID bytes
        PROTO_CHIP_ERASE =      0x23,   ///< erase program area and reset program address
        PROTO_LOAD_ADDRESS =    0x24,	///< set next programming address
        PROTO_PROG_MULTI =      0x27,   ///< write bytes at program address and increment
        PROTO_GET_CRC =         0x29,	///< compute & return a CRC
        PROTO_BOOT =            0x30,   ///< boot the application
        
        // Command bytes - Rev 2 boootloader only
        PROTO_CHIP_VERIFY	=   0x24, ///< begin verify mode
        PROTO_READ_MULTI	=   0x28, ///< read bytes at programm address and increment
        
        INFO_BL_REV         =   1,    ///< bootloader protocol revision
        BL_REV_MIN          =   2,    ///< Minimum supported bootlader protocol
Lorenz Meier's avatar
Lorenz Meier committed
131
        BL_REV_MAX			=   5,    ///< Maximum supported bootloader protocol
132 133 134 135
        INFO_BOARD_ID		=   2,    ///< board type
        INFO_BOARD_REV		=   3,    ///< board revision
        INFO_FLASH_SIZE		=   4,    ///< max firmware size in bytes
        
Don Gagne's avatar
Don Gagne committed
136 137
        PROG_MULTI_MAX		=   64,     ///< write size for PROTO_PROG_MULTI, must be multiple of 4
        READ_MULTI_MAX		=   0x28    ///< read size for PROTO_READ_MULTI, must be multiple of 4. Sik Radio max size is 0x28
138 139 140 141 142 143 144 145 146 147 148
    };
    
    uint32_t    _boardID;           ///< board id for currently connected board
    uint32_t    _boardFlashSize;    ///< flash size for currently connected board
    uint32_t    _imageCRC;          ///< CRC for image in currently selected firmware file
    uint32_t    _bootloaderVersion; ///< Bootloader version
    
    QString _firmwareFilename;      ///< Currently selected firmware file to flash
    
    QString _errorString;           ///< Last error
    
DonLakeFlyer's avatar
DonLakeFlyer committed
149 150 151 152 153 154 155
    static const int _eraseTimeout = 20000;                 ///< Msecs to wait for response from erase command
    static const int _rebootTimeout = 10000;                ///< Msecs to wait for reboot command to cause serial port to disconnect
    static const int _verifyTimeout = 5000;                 ///< Msecs to wait for response to PROTO_GET_CRC command
    static const int _readTimout = 2000;                    ///< Msecs to wait for read bytes to become available
    static const int _responseTimeout = 2000;               ///< Msecs to wait for command response bytes
    static const int _flashSizeSmall = 1032192;             ///< Flash size for boards with silicon error
    static const int _bootloaderVersionV2CorrectFlash = 5;  ///< Anything below this bootloader version on V2 boards cannot trust flash size
156 157 158
};

#endif // PX4FirmwareUpgrade_H