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. Customizing configuration steps (external document)
  4. Command Line Usage
  5. Troubleshooting
  6. Support (external document)
  7. Installation and Security (external document)
  8. FAQ (external document)
  9. Glossary

Before You Begin

⚠️ IMPORTANT: Connect your flight controller to the PC and wait at least 7 seconds before starting the software.

💡 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
    subgraph "Step 1: Connect to Vehicle"
        A[Connect Flight Controller] --> B{Auto-Detect?}
        B -->|Yes| C[Download FC Info]
        B -->|No| D[Manual Connection]
        D --> C
    end

    subgraph "Step 2: Select Project"
        C --> E{Existing Project?}
        E -->|Yes| F[Open Vehicle Directory]
        E -->|No| G[Select Template]
        G --> H[Create New Project]
        F --> I[Component Editor]
        H --> I
    end

    subgraph "Step 3: Edit FC Components"
        I --> J[Validate Components]
        J --> K{Valid?}
        K -->|No| I
        K -->|Yes| L[Parameter Editor]
    end

    subgraph "Step 4: Edit FC Parameters"
        L --> M[Configure Parameters]
        M --> N[Upload to FC]
        N --> O{Experiment Required?}
        O -->|Yes| P[Close AMC]
        P --> Q[Perform Experiment/Flight]
        Q --> R[Start AMC]
        R --> S[Read Results from FC]
        S --> T[Write Results to File]
        T --> U{More Files?}
        O -->|No| U
        U -->|Yes| L
        U -->|No| V[Generate Summary]
        V -->     W[Configuration Complete]
    end

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. Connect your flight controller to the PC via USB cable
  3. 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, this step will be skipped automatically and you’ll proceed directly to Step 3.

The connection selection interface is only presented if auto-connection fails or if no flight controller is detected.

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.

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, either from a template or from a .bin log file.

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 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.

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 in the previous step. The normal layout is explained below, the simple layout is similar but has less elements.

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"

Skip Steps for Faster Workflow

# Skip component editor (when components already configured)
ardupilot_methodic_configurator --skip-component-editor --vehicle-dir="C:\MyDrone"

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

# Combine multiple options for fastest startup
ardupilot_methodic_configurator --device="COM3" --vehicle-dir="C:\MyDrone" --skip-component-editor --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:

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. --skip-component-editor if you do not need to change the components and connections of your vehicle, this will skip the component and connection editor window.
  4. --n <number> this will skip directly to step number <number> so that you do not need to skip the previous steps
  5. --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.