ArduPilot Basic Configuration
A flight controller arrives knowing nothing about your aircraft. It does not know how many motors there are, where they are, which way they spin, what your ESCs speak, or what your transmitter's sticks mean. Basic configuration is the process of telling it. Everything in this guide has to be right before an ArduPilot multirotor will arm, and most of it has to be right before it will fly safely.
This guide is deliberately board-independent: it explains what each setting is for and names the parameter behind it, so it applies to any ArduPilot multirotor. If you would rather follow a click-by-click walkthrough on one specific board, the F405 V2 setup guide covers the same ground with screenshots.
It assumes ArduPilot Copter firmware is already on the board. If it is not, start with the Firmware Flashing Guide.
Every step here that makes a motor turn is done with propellers removed. Motor order and direction are exactly the things that are still wrong at this stage, and a quad that lifts off a bench with the wrong mixing does so violently and unpredictably.
How ArduPilot parameters work
ArduPilot's entire configuration is a flat list of about a thousand named numbers called parameters. FRAME_TYPE is a parameter. MOT_PWM_TYPE is a parameter. Every friendly setup screen in a ground station is a front end that writes parameters, which is why this guide names them: the screens change between versions, the parameter names rarely do.
Three things about parameters trip up almost everyone the first time.
Editing is not writing. When you connect, the ground station downloads the whole list and shows you a copy. Typing a new value changes that copy. Until you press the write button, the aircraft has not been told anything.
Some parameters need a reboot. Anything that changes the shape of the aircraft or the wiring — frame class and type, the ESC protocol, what a serial port is used for — is read once at startup. The new value is saved correctly but does nothing until the board restarts. ArduPilot marks these parameters as requiring a reboot, and ground stations pass that warning on.
A bitmask is several switches in one number. Parameters like the arming checks are not a single choice; each bit is an independent yes/no. Ground stations offer a tick-box editor for these, and it is always worth using it rather than typing a number — the arithmetic is easy to get wrong and the consequences are invisible.
Ground stations can save the whole parameter list to a file and load it back. Do that once when the aircraft flies well. It turns "I have changed forty things and now it is worse" from a disaster into a two-minute fix.
Tell it what the aircraft is
Frame class and frame type
Two parameters, and they are read at boot:
FRAME_CLASS— how many motors, in what family.FRAME_TYPE— how those motors are arranged.
FRAME_CLASS | Aircraft |
|---|---|
| 0 | Undefined — the factory default on many boards |
| 1 | Quad |
| 2 | Hexa |
| 3 | Octa |
| 4 | OctaQuad |
| 5 | Y6 |
| 6 | Heli |
| 7 | Tri |
| 10 | BiCopter |
| 14 | Deca |
A board shipped with FRAME_CLASS at 0 will not arm, and the message it gives is "Motors: Check frame class and type". That check is one ArduPilot always runs — it is not on the list you can switch off — so if you see it, no amount of relaxing the arming checks will help. Setting the class is often the very first thing a new build needs.
FRAME_TYPE then picks the layout. For a quad the values that matter are:
FRAME_TYPE | Layout |
|---|---|
| 0 | Plus — arms point forward, back, left, right |
| 1 | X — ArduPilot's own numbering |
| 3 | H |
| 12 | BetaFlightX |
| 13 | DJIX |
| 14 | ClockwiseX |
These are not cosmetic. They are four different answers to "which output drives which corner", and they disagree with each other on every single corner:
The airframe in that diagram never moves. Only the numbering does. This is why a board that flips over instantly on its first arming attempt is nearly always a frame-type problem rather than a tuning problem — the firmware is commanding the correct corner and the wrong motor is answering.
ArduPilot's hardware definition for a board can set a different default, and several boards built around the Betaflight ecosystem default to BetaFlightX rather than plain X. Do not assume; check the value, and then confirm it with a motor test.
ESC protocol
MOT_PWM_TYPE decides the language the flight controller uses to talk to the ESCs. It is read at boot.
MOT_PWM_TYPE | Protocol | Notes |
|---|---|---|
| 0 | Normal PWM | the default; needs ESC calibration |
| 1 | OneShot | |
| 2 | OneShot125 | |
| 3 | Brushed | small brushed motors, not ESCs |
| 4 | DShot150 | |
| 5 | DShot300 | the usual choice for a multirotor |
| 6 | DShot600 | |
| 7 | DShot1200 |
Plain PWM is an analogue signal: the throttle command is carried by how long a pulse lasts, the same way a servo is driven. DShot is digital: the command is a number, sent as a short burst of bits. The practical differences are that DShot cannot drift out of calibration, cannot be confused by a noisy wire, and needs no ESC calibration step at all.
The catch is the default. ArduPilot ships with MOT_PWM_TYPE = 0, and modern 4-in-1 ESCs running Bluejay or AM32 firmware are usually configured for DShot only. They will sit there receiving PWM pulses they do not understand and do nothing, silently, with no error anywhere. "The motor test does nothing" is the ESC protocol until proven otherwise.
DShot300 is the sensible default for a multirotor. Higher rates exist and are not better in any way you will notice on a normal aircraft; they are shorter bit periods, which makes them slightly less tolerant of long or badly routed signal wires.
Motor order and direction
Setting FRAME_TYPE tells ArduPilot what it should expect. It does not check. Verifying is a separate job and it is not optional.
With propellers removed and the flight battery connected, use your ground station's motor test. It spins one motor at a time in a defined order, and you are checking two things at once:
- Order — does the motor ArduPilot calls 1 sit at the corner the frame-type diagram says it should?
- Direction — does each motor turn the way the diagram says?
For ArduPilot's own X layout, motors 1 and 2 turn counter-clockwise and motors 3 and 4 turn clockwise.
A wrong order is fixed by moving the ESC signal wires, or by choosing the frame type that matches how you actually wired it. A wrong direction is fixed either by swapping any two of the three motor wires at the ESC, or in software by reversing that motor in an ESC configurator — see Configure ESC Parameters for the passthrough procedure.
Receiver
Set the protocol of the serial port the receiver is wired to — SERIAL1_PROTOCOL, SERIAL6_PROTOCOL and so on, depending on which port you used — to 23, which means RC input. On most flight controllers the port behind the connector marked RC is already set that way.
What the receiver speaks matters for the wiring, not for the parameter:
- SBUS is one-way. Only the receiver's signal wire needs to reach the flight controller's RX pin.
- ELRS and CRSF are two-way, so telemetry can flow back to your transmitter. Both wires are needed, and they cross: receiver TX to flight controller RX, receiver RX to flight controller TX.
Crossed-over wiring is the single most common ELRS mistake, and it produces exactly the same symptom as no wiring at all.
Make the sensors truthful
Calibration does not improve the aircraft. It removes lies. Each of these steps measures an error that is already there and stores a correction for it.
Accelerometer
The six-position calibration. You hold the aircraft still in six orientations — level, on each side, nose down, tail down, and inverted — and ArduPilot works out how each accelerometer axis is biased and scaled. That is why it takes six positions: three axes, two directions each.
The only thing that matters is that the aircraft is genuinely still in each position, and that "level" really is level. Everything ArduPilot later believes about which way is down comes from this.
Compass
The compass measures the Earth's magnetic field to know which way the aircraft is pointing. The problem is that your own aircraft is magnetic: motors, current-carrying wires and steel screws all add their own field, which rotates with the aircraft and so looks exactly like a heading change.
Calibration maps that interference so it can be subtracted. You rotate the aircraft through every orientation while it collects samples, and the firmware fits a correction to them. Two practical rules:
- Do it away from metal. Not on a car roof, not on a steel-framed desk, not indoors next to a radiator. Calibrating against a large local distortion bakes that distortion into the correction.
- Reboot afterwards, which ArduPilot will ask you to do.
An external compass — the one inside most GPS modules — is worth having precisely because it sits on a mast away from the power wiring. If you have one, it also has to be told which way round it is mounted; that is a separate parameter and its own topic, covered in External Compass Orientation.
Radio
Radio calibration teaches ArduPilot the endpoints of each channel: what number your transmitter sends at full left, at centre, at full right. Start it, then move every stick to both extremes and flip every switch through every position.
Before you run it, check the pitch channel direction. Push the pitch stick forward — the direction that should make the aircraft nose down — and confirm the ground station's pitch bar moves the way it is supposed to. If it is backwards, reverse that channel first. A reversed pitch channel that survives calibration produces an aircraft that flies into the ground when you tell it to climb.
ESC calibration
Included here mainly to say: if you are using DShot, there is no such step. ESC calibration teaches an analogue ESC which pulse width you mean by zero throttle and which by full throttle. DShot sends a number, so there is nothing to teach. Ignore any tutorial that tells you to calibrate ESCs on a DShot build.
Give it a starting tune
A multirotor's control loops have to be matched to the aircraft: a 3-inch quad and a 10-inch quad need very different numbers, and ArduPilot's defaults suit neither particularly well.
Mission Planner has an initial tune page that generates a sensible starting set from two numbers:
- Propeller size in inches — the propeller, not the frame. On a normal 5-inch quad these are the same number, which is where the confusion comes from; on anything unusual, enter the propeller.
- Battery cell count — 4 for a 4S pack, 6 for a 6S pack.
It calculates a set of PID and filter values and writes them to the board. This is not tuning — it is a starting point close enough that the aircraft is safe to fly and can then be tuned properly.
One value worth knowing about afterwards: INS_ACCEL_FILTER, the accelerometer filter cutoff, which defaults to 20 Hz on Copter and is among the values the initial tune page rewrites. If altitude hold turns out twitchy on a small frame, raising it to 30 is the usual fix.
Flight modes
FLTMODE_CH sets which RC channel selects the flight mode. It defaults to channel 5. Six mode slots are available, chosen by where that channel's value falls; a normal three-position switch reaches three of them.
| Mode | What it does | Needs |
|---|---|---|
| Stabilize | Self-levels; you control the throttle directly. The basic mode, and the one that always works. | nothing |
| AltHold | Holds height; throttle stick becomes climb and descent. | barometer |
| Loiter | Holds height and position. | a position source such as GPS |
| PosHold | Also holds position, but with more direct stick feel. | a position source |
| Acro | No self-levelling at all — sticks command rotation rate. | an experienced pilot |
| RTL | Flies back to where it was armed and lands. | GPS |
A good first set is Stabilize, AltHold, Loiter on one three-position switch. It also doubles as a test: if Loiter refuses to engage, your position source is not working, and it is far better to discover that on the ground.
Arming
The checks
Before ArduPilot will spin the motors it runs a list of pre-flight checks — is the barometer sane, does the compass agree with the GPS, are the sensors consistent, is the RC link alive, is the battery voltage plausible. All of them are on by default.
Which parameter controls them changed in ArduPilot 4.7, and the two are inverted:
| Firmware | Parameter | The bitmask lists | Default |
|---|---|---|---|
| 4.7 and later | ARMING_SKIPCHK | checks to skip | 0 — skip nothing |
| 4.6 and earlier | ARMING_CHECK | checks to perform | 1 — the "All" bit |
Upgrading a board from 4.6 to 4.7 converts your old value automatically, so an existing aircraft carries its settings across. The trap is following an older tutorial on newer firmware: the numbers it gives you will switch off precisely the checks it was telling you to keep.
Reducing the checks while bench testing is reasonable. Put them back before you fly. When a check refuses to pass, read what it is complaining about — the message names the problem, and the problem is real.
The gesture
ArduPilot's default stick arming is throttle down and to the right, held for three continuous seconds. Disarming is the mirror: throttle down and to the left, held for three seconds, with the aircraft on the ground.
Three seconds is longer than it feels. Most "it will not arm" reports from people who have never flown ArduPilot before are the gesture being released after one.
The gesture only works with throttle at minimum, and it can be disabled or restricted with ARMING_RUDDER.
A worked example: a 5-inch 4S quad
A common build — four motors in an X, a Bluejay 4-in-1 ESC, an ELRS receiver on a spare UART, a GPS module, 4S battery, 5-inch propellers:
FRAME_CLASS = 1 # Quad
FRAME_TYPE = 1 # X — but check your board's default first
MOT_PWM_TYPE = 5 # DShot300 — the Bluejay ESC needs this
SERIAL1_PROTOCOL = 23 # RC input, on whichever UART the receiver uses
FLTMODE_CH = 5 # default
Reboot after writing those. Then, in order: motor test with propellers off, accelerometer calibration, compass calibration, radio calibration, initial tune with propeller size 5 and cell count 4, flight modes on the switch, and a first arming — still with propellers off — to confirm all four motors spin up together and follow the throttle.
Only then do propellers go on, and the first flight is in Stabilize, outdoors, with plenty of space.
Easily confused points
Writing is a separate action from editing. A value typed but not written exists only on your computer.
Frame class and frame type are different things. Class is how many motors; type is where they are.
Motor numbers are ArduPilot's, not your ESC's. The pad marked 1 on the ESC board and the motor ArduPilot calls 1 have no relationship until you have checked.
"X" and "BetaFlightX" are not the same layout. Every output lands on a different corner.
The arming-check parameter was inverted in 4.7. ARMING_CHECK listed the checks to run; ARMING_SKIPCHK lists the checks to skip.
Calibration is not tuning. Calibration makes the sensors honest. The initial tune page makes the control loops sane. You need both, and neither substitutes for the other.
ESC calibration does not apply to DShot. If a guide tells you to do it on a DShot build, that guide predates your ESCs.
USB does not power the ESCs. Motor tests need the flight battery connected.
Troubleshooting
| Symptom | Where to look |
|---|---|
| Motors do nothing in the motor test | MOT_PWM_TYPE — set DShot300 and reboot. Then check the flight battery is connected. |
| "Motors: Check frame class and type" | FRAME_CLASS is still 0, or the class and type combination is not valid. Set it and reboot. |
| Will not arm, some other message | Read it — it names the problem. The pre-arm messages are specific, not generic. |
| Flips over immediately on takeoff | Motor order or direction. Land the parameters, then re-run the motor test with props off. |
| A parameter change has no effect | Re-read from the board. If it reverted, it was never written; if it is correct, the parameter needs a reboot. |
| No stick movement shown in the ground station | Receiver wiring — and for ELRS, whether TX and RX are crossed. Then the serial port's protocol. |
| Compass calibration never completes | Move away from metal and magnets, and keep rotating through all axes rather than spinning about one. |
| Altitude hold twitches on a small frame | Raise INS_ACCEL_FILTER to 30. |
| Arms on the bench but not in the field | A check that only fails outdoors is usually GPS or compass — and it is telling you something true. |
Related guides
- Flight Controller Firmware Flashing Guide
- MicoAir F405 V2 — Beginner ArduPilot Setup Guide
- Flight Controller Board Orientation
- External Compass Orientation
- Drone GPS & Compass Guide
- Configure ESC Parameters
Where to buy
Flight controllers that run ArduPilot, shipped from Canada with free Canada-wide shipping:
- MicoAir H743 V2 — the do-it-all flagship
- MicoAir F405 V2 — budget ArduPilot and INAV builds
Written and maintained by the Robofusion engineering team.