Build an active aero wing

What you are building.

A fixed wing is a compromise. Set it up for grip through a corner and it holds you back on the straight; set it up for a low-drag top speed and it gives you very little when you need the rear planted. This one does not pick. An accelerometer on the wing reads longitudinal acceleration and drives a servo to one of three angles.

Those figures are from CFD at a 30 mph inlet, so treat them as the shape of the behaviour rather than what your car will feel. The useful comparison is between them: going from neutral to cruise multiplies downforce roughly tenfold for under a newton of extra drag, and that is the whole argument for a cambered section that works at a shallow angle instead of a flat plate you have to tip into the wind.

Before you start.

None of this is difficult on its own. It is a printed part, a hobby servo and about forty lines of Arduino. The work is in getting the geometry right and being honest about the mounting.

• CAD you can loft in. Fusion 360 was used here. Any parametric package works.
• An FDM printer. Anything with a bed around 200 mm. The wing is printed in sections precisely so the bed size stops mattering.
• Soldering, at a basic level. A few dupont joints and a barrel jack.
• Enough Arduino to upload a sketch and read the serial monitor. The firmware is given in full below.

The parts.

You do not have to draw any of this. Every printable part is here, ready to slice. Download the lot, or pick off the ones you need.

Print them.

Nothing here needs an exotic printer. The wing is split into 200 mm sections precisely so bed size stops being the problem.

Low infill with three walls is the important pairing. On parts like these the shell carries the load, so walls buy you stiffness where infill would only add mass in the middle where it does least. Turning infill up will not make the wing meaningfully stronger; adding a wall will.

What you need.

Everything here was chosen for a reason, and the reason matters more than the part number. Where a substitution is safe, the note says so.

Swipe the table sideways for the rest of the columns.

Tools: a soldering iron (it does double duty for both the electrical work and for plastic-welding the wing seams), a heat-set insert tip, hex keys, and a laptop for the serial monitor during calibration.

Why the wing is this shape.

You do not need any of this to build one. It is here because knowing why a part looks the way it does is what lets you change it safely later.

The section is cambered, and mounted inverted. Right way up a cambered airfoil makes lift; upside down the same pressure difference works downward. It was then modified from stock: more curvature on the upper surface so the flow accelerates over it and static pressure drops, and a flatter lower surface to hold a higher-pressure region underneath. That asymmetry is the downforce. Chord is 190 mm, with 30 mm of drop from the leading edge down to the trailing edge.

The span is 1,400 mm in three pieces. A 900 mm centre at a constant profile does most of the work. The two 250 mm outboard pieces are lofted rather than extruded: the inboard end matches the centre profile exactly, the outboard end is a higher-angle version of it. That puts more downforce toward the tips and spreads load better across the span, with no hard geometric break for the flow to trip over.

The endplates do two jobs. A wingtip leaks, with high-pressure air curling around the end to the low-pressure side; that leak is induced drag and it eats the effective lift coefficient. A vertical plate blocks the path. They are also the structural mounting face, with M3 heat-set pockets moulded in so screws thread straight in and nothing needs a nut behind it.

Step 1. Assemble the wing.

Sections out of the printer, one wing at the end of it. Before that, a word on the route not taken, because it explains why the parts are shaped for printing in the first place.

Hot-wire cutting is only as good as the hand guiding it, and any deviation propagates through every slice in the stack. Fairing foam down to a CAD-defined profile is slow with no guaranteed dimensional accuracy, and lamination adds its own variables on top. Printing gives you the CAD geometry every time, and features that would be miserable to build into a foam core — hinge bores, dowel holes, insert pockets, servo mounting geometry — are simply part of the part. You pay for that in mass. It is worth it.

Step 2. Make it move.

The fewer parts between the servo shaft and the wing, the less slop there is to fight. This is a direct drive with nothing in between.

Step 3. Wire it.

Five components and a shared ground. The only part with a trap in it is where the servo power comes from.

Step 4. The firmware.

Three states, not a continuous curve. The wing lives at three defined angles, so a threshold comparison is enough and it is far more robust against sensor noise than a proportional loop would be. Everything interesting is what wraps around that comparison.

You need three libraries: Servo.h and Wire.h ship with the Arduino IDE, and MPU6050.h is the Electronic Cats library, installed through the Library Manager.

#include <Servo.h>
#include <Wire.h>
#include <MPU6050.h>

Servo servo1; Servo servo2;
MPU6050 mpu;

// Wing positions, in servo units. Calibrate these yourself, see below.
#define POS_NEUTRAL   110   // under acceleration
#define POS_CRUISE     65   // steady speed
#define POS_AIRBRAKE    0   // under braking

// Thresholds, in g, applied after the offset below
#define ACCEL_THRESHOLD  0.09
#define BRAKE_THRESHOLD -0.07

// Your mounting offset. Measure it, do not copy mine.
#define OFFSET         0.07
#define FILTER_SIZE      10   // rolling average window
#define CHANGE_DELAY   1000   // debounce, ms

float readings[FILTER_SIZE];
int filterIndex = 0;
float filterSum = 0;
unsigned long lastChangeTime = 0;
int currentPosition = POS_CRUISE;
int targetPosition  = POS_CRUISE;

void setWingPosition(int pos) {
  // The servos are mirrored across the hinge, so they take
  // supplementary angles or they fight each other.
  servo1.write(pos);
  servo2.write(180 - pos);
  currentPosition = pos;
}

float getFilteredAccel() {
  int16_t ax, ay, az, gx, gy, gz;
  mpu.getMotion6(&ax, &ay, &az, &gx, &gy, &gz);
  float accelG = (ax / 16384.0) - OFFSET;
  filterSum -= readings[filterIndex];
  readings[filterIndex] = accelG;
  filterSum += readings[filterIndex];
  filterIndex = (filterIndex + 1) % FILTER_SIZE;
  return filterSum / FILTER_SIZE;
}

void setup() {
  servo1.attach(5);
  servo2.attach(6);
  Serial.begin(9600);
  Wire.begin();
  mpu.initialize();
  Serial.println(mpu.testConnection() ? "MPU6050 connected"
                                      : "MPU6050 connection failed");
  for (int i = 0; i < FILTER_SIZE; i++) readings[i] = 0;
  setWingPosition(POS_CRUISE);
  Serial.println("Wing starting at cruise position");
}

void loop() {
  float accel = getFilteredAccel();
  Serial.print("Accel: "); Serial.print(accel); Serial.print("g -> ");

  if (accel > ACCEL_THRESHOLD) {
    Serial.println("NEUTRAL (accelerating)");
    targetPosition = POS_NEUTRAL;
  } else if (accel < BRAKE_THRESHOLD) {
    Serial.println("AIRBRAKE (braking)");
    targetPosition = POS_AIRBRAKE;
  } else {
    Serial.println("CRUISE");
    targetPosition = POS_CRUISE;
  }

  // Only commit once the new mode has held for CHANGE_DELAY.
  if (targetPosition != currentPosition) {
    if (millis() - lastChangeTime >= CHANGE_DELAY) {
      setWingPosition(targetPosition);
      lastChangeTime = millis();
    }
  } else {
    lastChangeTime = millis();
  }

  delay(50);   // 20 Hz
}

Step 5. Bench test, before it goes near the car.

Everything here is checkable on a desk with the Nano on USB and the 12 V pack feeding the buck. Do all of it.

Step 6. On the car.

Mine went on the trunk lid of a 2011 BMW E93. Nothing about the design is specific to that car, which was the point.

What broke, and what to do about it.

One failure, and it is the most useful thing in this guide because you can design it out before you print anything.

The connecting arm between the servo horn and the wing fractured during testing, at one of its thinner sections. The wall thickness there was not enough to carry the bending moment from the horn while the aerodynamic hinge moment was working on the wing at the same time. The system kept running afterwards, but with degraded positional accuracy on that side.

Where you could take it.

The architecture was drawn with more than one axis in mind, which is why the IMU's full six degrees of freedom are read even though the controller uses exactly one of them.

• A lateral axis. The lateral acceleration data is already there. A second servo axis on the hinge would let the wing tilt through a corner to generate a yaw-stabilising moment.
• Telemetry. Moving to an ESP32 buys wireless logging of wing angle, acceleration and mode state to a phone, which turns threshold tuning into something driven by data rather than by feel.
• A proper mount. Fastening to the trunk lid or lip instead of suction cups, which also lets you set the wing at a better height above the surface.

The full detail.

This guide is the practical half. The report behind it carries the design reasoning, the CFD method and results in full, and the references.