MethodicConfigurator

ArduPilot Methodic Configurator User Manual

Overview

ArduPilot Methodic Configurator is a PC software designed by ArduPilot developers to simplify the configuration of ArduPilot vehicles. Its graphical user interface (GUI) manages, edits and visualizes parameter files, as well as uploads parameters to the vehicle. It automates the tasks described in the How to methodically tune any ArduCopter tuning guide.

This user manual gives a general overview of the software functionality. There are also quick start instructions, specific use case instructions, and frequently asked questions.

Table of Contents

  1. Step-by-Step Workflow
  2. Configuring multiple similar vehicles
  3. Flight-Controller Parameter Export
  4. MAVFTP File Browser
  5. Firmware Upload
  6. Customizing configuration steps (external document)
  7. Command Line Usage
  8. Troubleshooting
  9. Support (external document)
  10. Installation and Security (external document)
  11. FAQ (external document)
  12. Glossary

Before You Begin

⚠️ IMPORTANT: If you will connect a flight controller, connect it to the PC and wait at least 7 seconds before starting the software. You can also work offline or create a project from a .bin log without connecting one.

💡 TIP: Have your vehicle’s component documentation ready (motor specifications, ESC type, etc.)

Step-by-Step Workflow

Don’t worry! It looks more complicated than it actually is. And you do not need to understand the diagram to use the software.

flowchart TD
    A[Start AMC] --> B{.bin log on command line?}
    B -->|Yes| M
    B -->|No| C

    subgraph "Step 1: Connect to Vehicle (optional)"
        C{Connect to Flight Controller?} -->|Yes| D{Auto-Detect?}
        D -->|Yes| E[Download FC Info and Parameters]
        D -->|No| F[Manual Connection]
        F --> E
        C -->|No, work offline| G[Continue without FC]
    end

    subgraph "Step 2: Select or Create Project"
        E --> H{Existing Project?}
        G --> H
        H -->|Yes| I[Open Vehicle Directory]
        H -->|No| J{Create from?}
        J -->|Configured FC, if connected| K[Create from Configured FC]
        J -->|Template| L[Select Template]
        L --> N[Create New Project]
        J -->|.bin log| M[Create from .bin Log]
    end

    subgraph "Step 3: Edit FC Components"
        O[Component Editor] --> P[Validate Components]
        P --> Q{Valid?}
        Q -->|No| O
    end

    subgraph "Step 4: Edit FC Parameters"
        R[Parameter Editor] --> S[Configure Parameters]
        S --> T{Advance how?}
        T -->|Upload to FC| U[Upload Selected Parameters]
        T -->|Skip or work offline| V[Skip Parameter File]
        U --> W{Experiment Required?}
        W -->|Yes| X[Close AMC]
        X --> Y[Perform Experiment/Flight]
        Y --> Z[Start AMC]
        Z --> AA[Read Results from FC]
        AA --> AB[Write Results to File]
        AB --> AC{More Files?}
        W -->|No| AC
        V --> AC
        AC -->|Yes| R
        AC -->|No| AD[Generate Summary]
        AD --> AE[Configuration Complete]
    end

    I --> R
    K --> O
    M --> O
    N --> O
    Q -->|Yes| R
    R -->|Edit vehicle components| O

If the diagram above does not display correctly look here

This section guides you through the complete configuration process. Follow these steps in order:

Preparation

  1. Collect your vehicle’s component documentation (motor specifications, ESC type, GPS Type, etc.)
  2. If using a flight controller, connect it to the PC via USB cable
  3. If connected, wait at least 7 seconds for the flight controller to fully boot
  4. Launch ArduPilot Methodic Configurator

Step 1: Flight Controller Connection

If the software successfully auto-detects your flight controller, it skips the connection selection window and downloads the flight controller information and parameters. You then select or create a project if needed (Step 2). If a project was supplied or found in the working directory, it proceeds directly to the parameter editor (Step 4).

The connection selection interface is only presented if auto-connection fails or if no flight controller is detected. You can also continue without a flight controller and edit a project offline. With --bin-log, AMC skips the connection and project selection windows, creates a project from the log, and opens the component editor (Step 3).

Flight Controller Connection Selection Interface

This interface allows users to select or add a connection to a flight controller if one was not yet auto-detected.

Flight controller connection selection window


Flight controller connection selection window

It provides three main options for connecting to a flight controller:

Choose your connection method:

Option 1: Auto-connect to flight controller ⭐ Recommended for most users

This option automatically detects and connects to your flight controller.

Option 2: Select flight controller connection ⚙️ For advanced users

Manually specify your connection details.

Use this setup to keep Mission Planner connected to the vehicle while AMC reads and changes parameters through Mission Planner. Mission Planner sends UDP traffic outbound; AMC listens for that traffic.

  1. Open Mission Planner.
  2. Connect to your vehicle and wait for telemetry to appear.

  3. Press Ctrl-F to open Mission Planner’s auxiliary tools window (titled temp).

    Mission Planner Ctrl-F auxiliary tools window with the Mavlink button

  4. Click Mavlink, described as “mirrors the mavlink stream received by mp”.

  5. In the forwarding window, configure an outbound UDP connection:

    Mission Planner Mavlink port forwarding window

    Setting Value when both applications run on the same PC
    Type / Protocol UDP
    Direction Outbound
    Port 14600
    Extra / Destination IP 127.0.0.1
    Write Enabled / True

    If your Mission Planner version uses a connection dropdown instead of a table, select UDP Client, enable Write, and enter the same destination IP and port when prompted.

  6. Start forwarding using the row’s Go control or the Connect button.
  7. Open AMC normally using its desktop shortcut or application launcher. If AMC would connect automatically to a different flight controller, disconnect that flight controller from the PC before opening AMC so the connection selection window appears.

  8. In AMC’s Manual connection section, open the Port dropdown and select Add another.

    AMC connection selector with Add another highlighted

  9. Enter udpin:0.0.0.0:14600 in the Flight Controller Connection dialog, then click OK. AMC will connect and retrieve the flight controller information and parameters.

    AMC custom connection dialog containing the UDP forwarding listener address

  10. Leave Mission Planner connected and forwarding while using AMC.

For advanced users, AMC can also be started from a terminal with an explicit listening connection, if its command is available on PATH:

ardupilot_methodic_configurator --device="udpin:0.0.0.0:14600"

Save this connection in a desktop shortcut: On Windows, right-click the AMC desktop shortcut, select Properties, and open the Shortcut tab. In Target, keep the existing executable path (including its quotes), then append a space followed by --device="udpin:0.0.0.0:14600". Click Apply, then OK. AMC will use this connection every time you launch that shortcut; Mission Planner must still be connected and forwarding.

You can also copy the shortcut and name it AMC - Mission Planner, leaving the original unchanged for other connections. Each shortcut can have different connection, project and startup settings. See Pro Tip: Desktop Shortcuts for more examples.

Important:

Option 3: No flight controller connection 📝 For offline editing

Work with parameter files without connecting to hardware.

Flight Controller Info and Parameter Download

If a flight controller is connected the software will now get information from it. The information is presented in the corresponding window and at the same time all flight controller parameters are downloaded to the PC.

Flight controller info and parameter download


Flight controller info and parameter download

Step 2: Vehicle Configuration Directory Selection

This interface allows users to select a vehicle directory that contains intermediate parameter files for ArduPilot if one was not specified with the --vehicle-dir command line parameter and if no configuration files were found in the current working directory.

Vehicle Selection Window


Vehicle Selection Window

It provides three main options for selecting a vehicle directory:

New

Create a new vehicle configuration directory from a template, an already configured flight controller, or a .bin log file.

When a correctly configured flight controller is connected, you can create a project directly from it:

Create vehicle from an already configured flight controller


Create vehicle from an already configured flight controller

Open

Open an existing vehicle configuration directory that already contains intermediate parameter files. It’s useful for editing an existing vehicle configuration.

Re-open

Re-open the last used vehicle configuration directory.

Create a New Vehicle Configuration Directory

Create new Vehicle Window


Create new Vehicle Window

Create a new vehicle configuration directory by copying files from an existing template directory. It’s useful for setting up a new vehicle configuration quickly.

Create a New Vehicle Configuration Directory from an Already Configured Flight Controller

This workflow is intended for a vehicle whose flight controller is already configured. It creates a new project using the live flight controller values and hardware information, while selecting the matching empty firmware template automatically.

Create vehicle project from an already configured flight controller


Create vehicle project from an already configured flight controller
  1. In the New panel, click Create a vehicle project from an already configured flight controller.
  2. Select the destination base directory.
  3. Enter a name for the new vehicle directory.
  4. Click the create button. AMC copies the matching empty template, substitutes the downloaded FC parameter values, and derives component specifications and connections from those values.
  5. AMC writes the FC’s default values to 00_default.param. Values that differ from the template baseline are written to xx_imported_flight_controller_parameters.param.

Create a New Vehicle Configuration Directory from a .bin Log File

If you have an ArduPilot .bin log file recorded by a correctly running vehicle, the software can build a complete project from it — no physical flight controller connection required.

Step 3: Vehicle Component Editor Interface

Here you specify the components of your vehicle, their properties and how they are connected to the flight controller.

Vehicle Component Editor Window - simple Vehicle Component Editor Window - normal

On the left with simple GUI complexity for beginners, on the right with normal GUI complexity.

Change every field to match your vehicle’s. When finished press the Save data and start configuration button.

The software will validate your input. If issues are found the problematic fields’ background will be marked in red color. Correct those entries and press the Save data and start configuration button again.

Step 4: Parameter File Editor and uploader interface

Here you sequentially configure the parameters of your flight controller to meet your needs while having all the available documentation at your fingertips.

For exporting the current flight-controller values, see the Flight-Controller Parameter Export guide.

Parameter File Editor and Uploader Window (main application)


Parameter File Editor and Uploader Window (main application) in simple GUI complexity for beginners

Parameter File Editor and Uploader Window (main application)


Parameter File Editor and Uploader Window (main application) in normal GUI complexity

The GUI complexity (simple or normal) is selected in the vehicle component editor window when creating a project. The normal layout is explained below, the simple layout is similar but has less elements.

When you open an existing project, AMC goes directly to the parameter editor. Use the Edit vehicle components button there to review or change the project’s component information.

Parameter editor and uploader workflow overview

Do this in a loop until the software tells you the process is finished and automatically closes:

1. See the Current Vehicle Directory (optional)

2. Select an Intermediate Parameter File (optional)

For more details on intermediate parameter files, see Intermediate Parameter Files.

When you click the ArduPilot logo the following window will appear: About and help information

4a. Configuration sequence progress bar

This segmented bar shows the progress in the vehicle configuration sequence. The progress bar is updated automatically when you upload an intermediate parameter file to the flight controller or select a different intermediate parameter file in the Current intermediate parameter file: combobox above it. The steps are grouped into phases and optional phases are greyed-out. There are mouse-over hints for each phase.

Parameter editor and uploader window

4b. Viewing Documentation

5. Editing Parameters

Editing parameters

6a. Focus on the changed parameters (optional)

6b. Annotate parameter metadata information into the parameter files (optional)

Annotate parameter metadata information into the parameter files in the form of comments preceding the respective parameter. It will create bigger and harder-to-compare parameter files but is more suitable for text editor editing.

7. Uploading Parameters to the Flight Controller

8. Skipping to the Next Parameter File (optional)

9. Completing the Configuration Process

Once all the intermediate parameter files have been processed, the ArduPilot Methodic Configurator will display a summary message box. In other words when the last available intermediate parameter file is selected (see 2. Select an Intermediate Parameter File) and either Upload selected params to FC, and advance to next param file or Skip parameter file button is pressed. This message box provides a comprehensive overview of the configuration process, including the number of parameters that were kept at their default values, the number of non-default read-only parameters that were ignored, and the number of non-default writable parameters that were updated.

Configuration summary message box

The summary message box will also categorize the writable parameters into four groups:

pie title Summary files example
    "Unchanged parameters" : 728
    "Non-default read-only parameters - non-default_read-only.param" : 8
    "Non-default writable sensor calibrations - non-default_writable_calibrations.param" : 71
    "Non-default writable IDs - non-default_writable_ids.param" : 3
    "Non-default writable non-sensor-calibrations, non-IDs - non-default_writable_non-calibrations_non-ids.param" : 217
    "Reusable parameters, including defaults - reusable.param" : 945

If the diagram above does not display correctly look here

After the summary message box is displayed, the application will write the summary information into separate files for easy reference and documentation. These files include:

The summary files provide a clear overview of the changes made.

The files are also automatically zipped into a file with the same name as the vehicle directory, inside the vehicle directory.

Parameter files zipped message box

Once the summary files are written, the application will close the connection to the flight controller and terminate.

Configuring multiple similar vehicles

  1. Create a separate vehicle configuration directory for each vehicle with a descriptive name
  2. Copy the *.param, *.json, *.jpg files to each directory
  3. Connect the PC to the vehicle flight controller and open the respective vehicle configuration directory in AMC
  4. Edit files to match each vehicle’s specific requirements

When manufacturing multiple vehicles of the same model, you can reuse most configuration files across instances. If you maintain high-quality standards that result in the production of multiple, nearly identical vehicles, only three parameter files are vehicle-specific:

Command Line Usage

The ArduPilot Methodic Configurator can be started from the command line. The command line interface provides several options to customize the behavior of the tool.

To use the command line interface, execute ardupilot_methodic_configurator on the command line.

Here is a list of command line options:

Example Usage Scenarios

Basic Usage (Auto-detection)

# Simplest form - auto-detect flight controller and use current directory
ardupilot_methodic_configurator

Specific Connection and Directory

# Windows - specify COM port and project directory
ardupilot_methodic_configurator --device="COM3" --vehicle-dir="C:\MyQuadcopter"

# Linux - specify USB device and project directory
ardupilot_methodic_configurator --device="/dev/ttyUSB0" --vehicle-dir="/home/user/MyQuadcopter"

# Network connection (SITL or network-connected FC)
ardupilot_methodic_configurator --device="tcp:127.0.0.1:5760" --vehicle-dir="/path/to/params"

Create a Project from a .bin Log

# Use the empty template inferred from the vehicle type and firmware in the log
ardupilot_methodic_configurator --bin-log="C:\logs\flight.bin"

# Use a specific template directory instead of the inferred empty template
ardupilot_methodic_configurator --bin-log="C:\logs\flight.bin" --template-dir="C:\templates\Holybro_X500"

After the project is created from the log, AMC continues through the normal GUI workflow: the Vehicle Component Editor opens first, followed by the parameter editor and uploader.

Start with an Existing Project

# Existing projects open directly in the parameter editor
ardupilot_methodic_configurator --vehicle-dir="C:\MyDrone"

# Start from specific parameter file (skip earlier steps)
ardupilot_methodic_configurator --n=5 --vehicle-dir="C:\MyDrone"

# Combine options when opening an existing project
ardupilot_methodic_configurator --device="COM3" --vehicle-dir="C:\MyDrone" --n=3

Different Vehicle Types

# Fixed-wing aircraft
ardupilot_methodic_configurator -t ArduPlane --vehicle-dir="C:\MyPlane"

# Rover/boat
ardupilot_methodic_configurator -t Rover --vehicle-dir="C:\MyRover"

# Helicopter
ardupilot_methodic_configurator -t Heli --vehicle-dir="C:\MyHeli"

Debugging and Development

# Enable debug logging for troubleshooting
ardupilot_methodic_configurator --loglevel=DEBUG --vehicle-dir="C:\MyDrone"

# Skip update check (for offline use)
ardupilot_methodic_configurator --skip-check-for-updates --device="COM3"

# Combine debugging options
ardupilot_methodic_configurator --loglevel=DEBUG --skip-check-for-updates --device="COM3"

Pro Tip: Desktop Shortcuts

Create multiple desktop shortcuts for different projects or connection settings. On Windows, copy an existing AMC shortcut, rename it, then right-click it and select Properties → Shortcut. Append the desired options to Target, after the existing executable path and a separating space. Keep any quotes around the executable path. Click Apply, then OK to save the options for every launch of that shortcut. If an option such as --device is already present, replace its value rather than adding it twice.

For example, a shortcut named AMC - Mission Planner can append --device="udpin:0.0.0.0:14600" to use the Mission Planner forwarding connection. Keep a separate shortcut without this option for automatic connection detection.

Shortcut 1 (MyQuadcopter):

Target: ardupilot_methodic_configurator.exe --device="COM3" --vehicle-dir="C:\MyQuadcopter"

Shortcut 2 (MyPlane):

Target: ardupilot_methodic_configurator.exe --device="COM4" --vehicle-dir="C:\MyPlane" -t ArduPlane

For more detailed information on command line options, run:

ardupilot_methodic_configurator --help

This will show a list of all available command line options along with a brief description of each.

For command line completion setup, see the Installation Guide.

Speed up software start

To speed up the startup of the ArduPilot methodic configurator, consider the following tips, presented from most to least effective:

All of these can be either added in the command line as a parameter, or in the “properties > link > target” of the desktop icon. Use an empty space to separate each option.

  1. --device <devicename> this explicitly connects to <devicename> skipping the auto-detection process.
  2. --vehicle-dir <vehicle-directory> this explicitly looks for project files in <vehicle-directory> saving you the trouble to manually select it in the GUI.
  3. --n <number> this will skip directly to step number <number> so that you do not need to skip the previous steps
  4. --skip-check-for-updates this saves very little time on startup, but you can skip it using this.

Pro tip: create multiple desktop icons, each one with a different project and or configuration.

Troubleshooting

Common Issues and Solutions

Connection Problems

Issue: “No flight controller detected” or auto-connect fails

Solutions:

  1. Check physical connection: Ensure USB cable is properly connected
  2. Incorrect serial baudrate: If the serial baudrate is different from 115200 you must connect manually
  3. Wait longer: Flight controller needs 7+ seconds to boot fully
  4. Try different USB port: Some ports may have power/data issues
  5. Check USB cable: Try a different cable (data cable, not just power)
  6. Manual connection: Use Option 2 and select the correct COM port
  7. Driver issues: Install flight controller drivers if needed

Issue: “Connection lost during operation”

Solutions:

  1. Check USB connection: Ensure cable isn’t loose
  2. Restart software: Close and reopen the configurator

Parameter File Issues

Issue: “Parameter file not found” or “Invalid parameter file”

Solutions:

  1. Check file location: Ensure parameter files are in the correct directory
  2. File permissions: Verify you have read/write access to the directory
  3. File format: Ensure parameter files follow the correct format
  4. Regenerate defaults: Use extract_param_defaults if 00_default.param is missing

Issue: “Parameter upload failed” or “Parameter validation error”

Solutions:

  1. Check parameter values: Ensure values are within valid ranges
  2. Flight controller firmware: Verify firmware version compatibility
  3. Retry upload: Some parameters require multiple attempts

Component Issues

Issue: “Component validation failed”

Solutions:

  1. Review component settings: Check all required fields are filled
  2. Component compatibility: Ensure components are compatible with your flight controller
  3. Firmware limitations: Some components require specific firmware versions
  4. Documentation: Consult component manufacturer specifications

Application Issues

Issue: Software crashes or freezes

Solutions:

  1. Restart software: Close and reopen the configurator
  2. Check system resources: Ensure adequate RAM and disk space
  3. Update software: Check for newer version of the configurator
  4. Log files: Check application logs for detailed error information
  5. Safe mode: Try running with --loglevel DEBUG for more information

Issue: GUI elements not displaying correctly

Solutions:

  1. Display scaling: Adjust Windows display scaling settings
  2. Screen resolution: Ensure minimum resolution requirements are met
  3. Graphics drivers: Update graphics card drivers
  4. Compatibility mode: Try running in compatibility mode (Windows)

Getting Help

For detailed support information, troubleshooting guidance, and how to report issues, see the Support Guide.

Installation and Security Verification

For detailed installation instructions and installer security verification, see the Installation Guide.

Frequently Asked Questions

For comprehensive answers to common questions about the ArduPilot Methodic Configurator, please see our dedicated FAQ document.

The FAQ covers:

💡 Quick Access: View Complete FAQ →

Glossary

ArduPilot: Open-source autopilot software suite for unmanned vehicles, providing autonomous flight capabilities

Bitmask Parameter: A parameter where each bit represents a different option that can be enabled/disabled independently

Component Editor: Interface for specifying vehicle hardware components and their connections to the flight controller

ESC: Electronic Speed Controller - controls motor speed based on flight controller commands

FC: Flight Controller - the main computer hardware that runs ArduPilot firmware and controls the vehicle

Firmware: The ArduPilot software program running on the flight controller hardware

Flight Mode: Different operational modes of the vehicle (Manual, Stabilize, Auto, etc.)

IMU: Inertial Measurement Unit - sensors that measure acceleration and rotation (accelerometer + gyroscope)

Intermediate Parameter File: A .param text file containing a subset of parameters for a specific configuration step

MAVLink: The communication protocol used between ground control software and flight controllers

Parameter: A configuration value that controls flight controller behavior (over 1200 available)

Parameter Documentation: Detailed descriptions of what each parameter controls, including valid ranges and units

Parameter Template: A pre-configured set of parameter files for a specific vehicle type or configuration

PID Controller: Proportional-Integral-Derivative controller used for flight stabilization and navigation

SITL: Software In The Loop - ArduPilot simulation environment for testing without hardware

Template Directory: Folder containing pre-configured parameter files that can be copied for new vehicle setups

Vehicle Instance: A specific physical vehicle with unique calibration parameters (vs. reusable template parameters)

Vehicle Type: The category of vehicle (ArduCopter, ArduPlane, etc.) that determines available parameters and features

This site is open source. Improve this page.