Bootloader.h 7.88 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
    static const int boardIDPX4FMUV4PRO = 13;   ///< PX4 V4PRO board, as from USB PID
68
    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
77
    static const int boardIDOmnibusF4SD = 42;   ///< Omnibus F4 SD, as from USB PID
78
    static const int boardIDFMUK66V3 = 28;    ///< FMUK66V3 board, as from USB PID
DonLakeFlyer's avatar
DonLakeFlyer committed
79 80 81 82 83

    /// 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;

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

    enum {
        // protocol bytes
        PROTO_INSYNC =          0x12,   ///< 'in sync' byte sent before status
110
        PROTO_BAD_SILICON_REV = 0x14,   ///< device is using silicon not suitable for the target the bootloader was used for
111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
        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
133
        BL_REV_MAX			=   5,    ///< Maximum supported bootloader protocol
134 135 136 137
        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
138 139
        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
140 141 142 143 144 145 146 147 148 149 150
    };
    
    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
151 152 153 154 155 156 157
    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
158 159 160
};

#endif // PX4FirmwareUpgrade_H