RC plane elevon and V-tail mixer on an Arduino Uno

// RC plane servo mixer: elevon or V-tail mixing on an Arduino, from two
// joysticks standing in for a transmitter's sticks.
//
//   left stick   VRX (rudder) on A0
//   right stick  VRX (aileron) on A1, VRY (elevator) on A2
//   switch       MODE on pin 4: elevon one way, V-tail the other
//   servos       left surface on pin 9, right surface on pin 10,
//                from a separate 5 V supply with the grounds joined
//
// WHY MIX. A flying wing has no tail: two surfaces on the back edge of the
// wing, called elevons, do the work of the elevator and the ailerons. For
// pitch both move the same way; for roll they move opposite ways. So each
// servo gets a sum:
//
//     left  = elevator + aileron
//     right = elevator - aileron
//
// A V-tail is the same idea with the rudder in place of the ailerons: two
// tail surfaces at a V make pitch moving together and yaw moving apart.
//
//     left  = elevator + rudder
//     right = elevator - rudder
//
// Every value here is a percent of full stick, -100 to +100. The sums can
// reach 200, so each one is held to +/-100: at full up and full roll
// together, one surface sits at its end and the other in the middle.
//
// RC SERVO PULSES. Model servos and receivers speak in pulse widths: 1500
// microseconds is center and 1000 to 2000 is full travel, 50 times a second.
// The servos are attached with that window, and writeMicroseconds() sends
// the width outright.

#include <Servo.h>

Servo leftServo, rightServo;

const int MODE_PIN = 4;

// If a surface moves the wrong way on your model, set its entry to true.
const bool REVERSE_LEFT = false;
const bool REVERSE_RIGHT = false;

// A small dead band, so a stick that does not center perfectly reads 0.
const int DEAD_BAND = 3;  // percent

// A stick's reading, 0 to 1023, as -100 to +100 percent.
int stickPercent(int pin) {
  int percent = map(analogRead(pin), 0, 1023, -100, 100);
  if (abs(percent) <= DEAD_BAND) percent = 0;
  return percent;
}

// A percent, -100 to +100, as a pulse width, 1000 to 2000 microseconds.
int toPulse(int percent, bool reverse) {
  if (reverse) percent = -percent;
  return 1500 + percent * 5;
}

int lastLeft = 0, lastRight = 0;
bool lastElevon = false;

void setup() {
  pinMode(MODE_PIN, INPUT_PULLUP);
  leftServo.attach(9, 1000, 2000);
  rightServo.attach(10, 1000, 2000);
  Serial.begin(115200);
  Serial.println("servo mixer: move the sticks, flip MODE for elevon or V-tail");
}

void loop() {
  bool elevonMode = digitalRead(MODE_PIN) == HIGH;
  int elevator = stickPercent(A2);
  // In elevon mode the right stick's sideways axis rolls; in V-tail mode
  // the left stick's sideways axis yaws.
  int other = elevonMode ? stickPercent(A1) : stickPercent(A0);

  int left = constrain(elevator + other, -100, 100);
  int right = constrain(elevator - other, -100, 100);

  int leftPulse = toPulse(left, REVERSE_LEFT);
  int rightPulse = toPulse(right, REVERSE_RIGHT);
  leftServo.writeMicroseconds(leftPulse);
  rightServo.writeMicroseconds(rightPulse);

  // Report a change once.
  if (leftPulse != lastLeft || rightPulse != lastRight || elevonMode != lastElevon) {
    lastLeft = leftPulse;
    lastRight = rightPulse;
    lastElevon = elevonMode;
    Serial.print(elevonMode ? "elevon  elevator " : "V-tail  elevator ");
    Serial.print(elevator);
    Serial.print(elevonMode ? "%  aileron " : "%  rudder ");
    Serial.print(other);
    Serial.print("%  ->  left ");
    Serial.print(leftPulse);
    Serial.print(" us  right ");
    Serial.print(rightPulse);
    Serial.println(" us");
  }
  delay(20);
}