Rotary Switches

A rotary switch rests in one of several positions . Inside, a wiper connected to a common terminal touches one contact at a time. Unlike an encoder it has end stops and every position is a fixed place, so the panel always shows the real selection — even after a power cycle. A two-position selector is just a toggle switch.

Break-before-make vs make-before-break

Either style works, as long as the code ignores those in-between moments and only reports a position once the contacts have settled.

Wire the common terminal to GND and each position's contact to its own input with the internal pull-up enabled. The selected position reads LOW, every other contact reads HIGH. A rotary switch needs between 3 and 12 positions wired this way.

Out of pins?

A 12-position selector costs up to 12 GPIOs. Put all of its contacts on the channels of one I/O expander instead, such as an MCP23017 or a 74HC165 chain — keep every contact of one switch on the same expander. Resistor-ladder selectors that put all positions on one ADC pin can be read as an Analog Input with a range lookup.

Scan the contacts and turn them into one position number. No closed contact means the unwired position; two closed contacts means the knob is between positions.

// Magneto switch: OFF has no contact, R/L/BOTH/START have one each
const int   CONTACT_PINS[] = { 25, 26, 27, 14 };   // positions 1–4
const char* NAMES[]        = { "OFF", "R", "L", "BOTH", "START" };
const int   CONTACTS       = 4;

int lastPosition = -1;

int readPosition() {
    int closed = -1;
    for (int i = 0; i < CONTACTS; i++) {
        if (digitalRead(CONTACT_PINS[i]) == LOW) {
            if (closed != -1) {
                return -2;               // two contacts closed: between positions
            }
            closed = i + 1;
        }
    }
    return closed == -1 ? 0 : closed;    // none closed = the unwired OFF position
}

void setup() {
    Serial.begin(115200);
    for (int i = 0; i < CONTACTS; i++) {
        pinMode(CONTACT_PINS[i], INPUT_PULLUP);
    }
}

void loop() {
    int position = readPosition();
    if (position >= 0 && position != lastPosition) {
        lastPosition = position;
        Serial.println(NAMES[position]);
    }
    delay(10);
}

Turning a magneto key quickly from OFF to BOTH passes R and L on the way. Sending each of them to the simulator would fire their commands. Wait until the contacts have been stable for the debounce time and report only where the knob came to rest.

// Only report a Position once the contacts have been stable for DEBOUNCE_MS
const int DEBOUNCE_MS = 50;

int      candidate   = -1;
uint32_t candidateAt = 0;

void loop() {
    int position = readPosition();          // from the sketch above

    if (position != candidate) {
        candidate   = position;
        candidateAt = millis();
        return;
    }

    bool settled = millis() - candidateAt >= DEBOUNCE_MS;
    // -2 (two contacts) is a transition, never a place the knob rests
    if (settled && candidate >= 0 && candidate != lastPosition) {
        lastPosition = candidate;
        Serial.println(NAMES[lastPosition]);
    }
}

On a CockpitConnect controller you don't write this: the board turns the contacts into a single position change, counted from 0, once they have been stable for the pin's debounce time (50 ms by default, tunable in the Flow Builder). What each position means — a dataref value or a command — is set on the Mapping.