Use AI to build your first cockpit module: four LEDs and an OLED

Start with a goal you can actually check

Imagine a small status panel beside your steering wheel or flight controls. Four lights show states, while an OLED shows speed, engine RPM and fuel. In this first build the numbers deliberately come from the Arduino IDE Serial Monitor. No running simulator is required, and you can trigger every response yourself.

The requirement is straightforward: control four LEDs independently and show the received values clearly. The program must validate complete messages, accept valid fields together and identify stale information. The outcome is a working building block you can understand, rather than a promise of an automatically integrated simulator device.

AI can explain connections, draft code and help interpret errors. Your job is to describe what should happen, when it should happen and what success looks like. You can answer those questions before learning terms such as variable or function. Ask for unfamiliar concepts to be explained using the part of this circuit you are currently testing.

The exact components used in this example

Prepare an Arduino Uno R3, a USB data cable, breadboard, jumper wires, four ordinary red indicator LEDs and four individual 1 kΩ resistors rated at least 0.125 W. The specified OLED is Adafruit product 4440: SSD1306, 128 × 32 pixels, I²C address 0x3C and automatic reset. Use a suitable STEMMA QT breakout cable or correctly fitted header pins.

The manufacturer explicitly supports 5 V logic for this particular module. That does not make every similar-looking OLED safe on a Uno: its controller, pin order, power supply and signal levels must match its own documentation. A SH1106 display or an older board requiring a reset wire needs changes. Check the actual product identity before applying power.

The Uno R3 is adequate for this small exercise. Limited working memory is a good reason to begin with a modest text display. The microcontroller comparison explains what to consider when your next project needs larger graphics, additional devices or a more capable processor.

Connect four LEDs and the OLED

Disconnect USB before assembling the circuit or moving wires. Establish a common ground, then connect one function at a time. Every LED needs its own series resistor; one resistor shared by all four is unsuitable. The anode is usually the longer lead, while the flat edge identifies the cathode side. For trimmed leads, check the component marking or datasheet.

With an approximate red-LED forward voltage of 2 V, a 5 V output and 1 kΩ produce about 3 mA. This deliberately modest current is useful for a desk experiment. The circuit is not intended for LED strips, powerful illumination or external voltage sources. See LED lighting before expanding the output hardware.

Define what each incoming value means

Our learning protocol is V1,speed,rpm,fuel,flags, followed by an LF newline, at 115200 baud. Only nonnegative integers are accepted: speed 0–999, RPM 0–20000, fuel 0–100 and flags 0–15. Do not add spaces, units or decimal punctuation. Send no more than five complete messages per second for this exercise.

The flags value is a sum: LED 1 contributes 1, LED 2 contributes 2, LED 3 contributes 4 and LED 4 contributes 8. Therefore 5 lights LEDs 1 and 3, 15 lights all four and 0 switches them all off. The displayed LED digits run from LED 1 to LED 4, left to right; 1010 therefore represents LEDs 1 and 3 on.

At startup the screen says WAIT. A valid message returns OK over serial and shows DATA. An invalid message returns ERR without partially replacing the last valid values. After three seconds without a valid message, all LEDs turn off and the screen changes to STALE, retaining the old numbers as visibly outdated information. This behaviour belongs in the requirements from the beginning.

In this example, S means speed in km/h, R means revolutions per minute and F means fuel percentage. The sketch displays the numbers unchanged; any later unit conversion belongs on the sending side. The four LED bits are test indicators with no predefined simulator meaning.

Give AI a complete brief, not just “write some code”

A useful Arduino prompt includes hardware, data and observable behaviour. Supply manufacturer links and your confirmed product identity. Ask first for a connection list and any unanswered questions. If your parts differ, resolve those differences before trusting a generated wiring description. Then use a complete brief such as this:

Help a beginner build a cockpit learning module. Explain each step clearly and do not invent pins or simulator interfaces.
Hardware: Arduino Uno R3; four red LEDs on D2,D3,D4,D5, each through 1 kOhm, cathodes to GND. OLED Adafruit 4440, SSD1306 128x32 I2C 0x3C; VIN=5V, GND=GND, SDA=A4, SCL=A5, automatic reset without a reset wire.
Task: Write a complete Arduino sketch using Wire, Adafruit GFX and Adafruit SSD1306. Receive my own USB-serial test lines at 115200 baud, at most 5 lines/s: V1,speed,rpm,fuel,flags followed by LF; accept CRLF. Ranges: speed 0..999, rpm 0..20000, fuel 0..100, flags 0..15. Values 1,2,4,8 select LED1..4.
Result: Show values and LED states in four text lines. Start with WAIT; valid data gives DATA/OK. Invalid messages give ERR with no partial update. After 3000 ms without valid data, LEDs off and STALE shown while retaining the last numbers.
Limits: Fixed 64-byte receive buffer; discard overlong lines through the next newline; no dynamic String objects or delay in loop; redraw no faster than every 200 ms. Account for SRAM including the 512-byte display buffer. Explain communication and allocation failures.
Provide wiring, complete code, libraries and tests for each LED, all LEDs, invalid values, overlong messages and interrupted data. Distinguish compilation from physical verification.

Prepare, upload and understand the sketch

In Arduino IDE select “Arduino Uno” and its port. Use Library Manager to install Adafruit SSD1306 and Adafruit GFX Library, including the Adafruit BusIO dependency. Wire comes with the AVR board package. Open the downloaded sketch inside a matching uno-led-oled folder, verify it first, then upload it to your own board.

The full code is shown below and available as a download. Its application logic does not wait with delay(): input is processed incrementally and the display refreshes at most five times per second. The I²C transfer itself still takes time. This is not a hard real-time guarantee, and longer wiring or extra bus devices require separate testing.

The display buffer needs 512 bytes in addition to variables, library buffers and stack space. The IDE static RAM figure does not fully account for this runtime allocation. Constant messages use F() to remain in flash; reception is bounded and does not use Arduino String objects. A successful compilation does not prove that the wiring or display works.

This sketch was compiled locally for arduino:avr:uno using AVR core 1.8.7, Adafruit SSD1306 2.5.9, GFX 1.11.9 and BusIO 1.15.0: 15,168 bytes of flash and 614 bytes of static RAM. Allow for the additional 512-byte display allocation. No physical assembly was tested here.

Download the complete Arduino sketch

// Cockpit Suite workshop learning example. This is not a simulator protocol.
// Board: Arduino Uno R3. OLED: Adafruit 4440, SSD1306 128x32, I2C 0x3C.
// OLED VIN=5V, GND=GND, SDA=A4, SCL=A5; auto-reset, no reset wire.
// LEDs: D2/D3/D4/D5 -> individual 1k resistor -> anode; cathodes -> GND.
// Send at most 5 lines/second: V1,speed,rpm,fuel,flags followed by LF.
// Example: V1,120,3500,65,5 (LED1 and LED3 on). CR before LF is accepted.
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>
#include <string.h>

const uint8_t LED_PINS[4] = {2, 3, 4, 5};
const uint8_t OLED_ADDRESS = 0x3C;
const uint32_t DATA_TIMEOUT_MS = 3000;
const uint32_t SCREEN_INTERVAL_MS = 200;
Adafruit_SSD1306 display(128, 32, &Wire, -1);
char lineBuffer[64];
uint8_t lineLength = 0;
bool discardLine = false;
bool haveData = false;
bool oledReady = false;
uint16_t speedValue = 0, rpmValue = 0, fuelValue = 0, flagValue = 0;
uint32_t lastDataMs = 0, lastScreenMs = 0;

bool parseNumber(const char *&cursor, uint16_t limit, char separator,
                 uint16_t &result) {
  if (*cursor < '0' || *cursor > '9') return false;
  uint16_t value = 0;
  while (*cursor >= '0' && *cursor <= '9') {
    uint8_t digit = *cursor++ - '0';
    if (value > limit / 10 ||
        (value == limit / 10 && digit > limit % 10)) return false;
    value = value * 10 + digit;
  }
  if (*cursor != separator) return false;
  if (separator != '\0') ++cursor;
  result = value;
  return true;
}

bool parseLine(const char *line) {
  if (strncmp(line, "V1,", 3) != 0) return false;
  const char *cursor = line + 3;
  uint16_t speed, rpm, fuel, flags;
  if (!parseNumber(cursor, 999, ',', speed) ||
      !parseNumber(cursor, 20000, ',', rpm) ||
      !parseNumber(cursor, 100, ',', fuel) ||
      !parseNumber(cursor, 15, '\0', flags)) return false;
  speedValue = speed;
  rpmValue = rpm;
  fuelValue = fuel;
  flagValue = flags;
  lastDataMs = millis();
  haveData = true;
  return true;
}

void readSerial() {
  // Bound each pass so a continuous stream cannot starve the outputs.
  for (uint8_t count = 0; count < 32 && Serial.available(); ++count) {
    char character = (char)Serial.read();
    if (character == '\r') continue;
    if (character == '\n') {
      lineBuffer[lineLength] = '\0';
      if (!discardLine && parseLine(lineBuffer)) Serial.println(F("OK"));
      else Serial.println(F("ERR"));
      lineLength = 0;
      discardLine = false;
    } else if (!discardLine) {
      // NUL and non-printable input are not part of this text protocol.
      if (character < 32 || character > 126 ||
          lineLength >= sizeof(lineBuffer) - 1) {
        discardLine = true;
      } else {
        lineBuffer[lineLength++] = character;
      }
    }
  }
}

void renderScreen(bool fresh) {
  display.clearDisplay();
  display.setCursor(0, 0);
  display.print(F("S:")); display.print(speedValue);
  display.print(F(" R:")); display.println(rpmValue);
  display.print(F("F:")); display.print(fuelValue);
  display.print(F("% LED:"));
  for (uint8_t index = 0; index < 4; ++index)
    display.print(fresh && (flagValue & (1U << index)) ? '1' : '0');
  display.println();
  display.println(!haveData ? F("WAIT") : (fresh ? F("DATA") : F("STALE")));
  display.print(F("DEMO SERIAL"));
  display.display();
}

void setup() {
  for (uint8_t index = 0; index < 4; ++index) {
    digitalWrite(LED_PINS[index], LOW);
    pinMode(LED_PINS[index], OUTPUT);
  }
  Serial.begin(115200);
  Wire.begin();
#if defined(WIRE_HAS_TIMEOUT)
  Wire.setWireTimeout(25000, true);
#endif
  Wire.beginTransmission(OLED_ADDRESS);
  bool addressResponds = (Wire.endTransmission() == 0);
  oledReady = addressResponds &&
      display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDRESS, false, false);
  if (oledReady) {
    display.setTextSize(1);
    display.setTextColor(SSD1306_WHITE);
    display.setTextWrap(false);
    renderScreen(false);
  } else {
    Serial.println(F("OLED ERROR: check model, wiring, address, RAM"));
  }
  Serial.println(F("READY: V1,speed,rpm,fuel,flags"));
}

void loop() {
  readSerial();
  uint32_t now = millis();
  bool fresh = haveData && (uint32_t)(now - lastDataMs) < DATA_TIMEOUT_MS;
  for (uint8_t index = 0; index < 4; ++index)
    digitalWrite(LED_PINS[index],
                 fresh && (flagValue & (1U << index)) ? HIGH : LOW);
  if (oledReady && (uint32_t)(now - lastScreenMs) >= SCREEN_INTERVAL_MS) {
    lastScreenMs = now;
    renderScreen(fresh);
  }
}

Check the result with specific test messages

After uploading, set Serial Monitor to 115200 baud and “Newline” or “Both NL & CR”. Opening the port may reset the Uno, so wait for READY. On initial startup the OLED should say WAIT and all four LEDs should remain off.

Send V1,120,3500,65,1: only LED 1 should light. Replace the final number with 2, 4 and 8 to check each output separately. V1,120,3500,65,15 turns on all four; a final 0 turns them off. Compare all three numbers on screen with your input. Also check the limits with V1,999,20000,100,15 and V1,0,0,0,0.

Intentionally send V1,120,3500,101,5 or omit a field. Expect ERR without a partial update. A line longer than 63 characters must be discarded until its newline; the next valid line must work normally. Wait more than three seconds: LEDs must go off and STALE must appear. A fresh valid line must restore operation. Keep expected and observed results in separate notes.

For a direct comparison: V1,120,3500,65,15 switches all four LEDs on, V1,120,3500,65,0 switches all off, and V1,120,3500,65,5 switches on only LEDs 1 and 3.

When something fails, narrow the question

A dark LED first calls for checking its polarity, individual resistor and assigned pin. A dark OLED calls for checking the product identity, power, ground, SDA/SCL and address. OLED ERROR can indicate a missing bus response or a failed memory allocation. Even a responding I²C address does not prove the image is correct.

Ask AI with a precise observation: “Uno R3, product 4440, unchanged sketch. READY appears, V1,120,3500,65,1 returns OK and LED1 lights, but the OLED stays dark. Which unpowered wiring checks should I do first?” Include library versions and the full compiler error when compilation fails. Request one justified change at a time; several simultaneous rewires hide the actual cause.

Save a working sketch before asking for extensions. Have the changes explained and repeat the test sequence afterwards. The troubleshooting guide gives a systematic process. Do not include passwords, private configuration or unrelated project folders in a help prompt.

Turn the learning exercise into a simulator display

Real simulator values need a documented PC-side route: obtain the source data, convert units, validate values and send the agreed message. This V1 format is only a learning example, not an advertised Cockpit Suite interface. Establish the supported device path before planning an automatic bridge. Serial Monitor and another application usually cannot own the same port simultaneously.

For each indicator, decide what it proves: a requested switch position or a confirmed simulator state? How should missing data differ from a state that is simply off? Continue with data mapping and displays and instruments to work through those questions.

If your main goal is buttons and axes as a USB joystick, FreeJoy offers a different starting point on suitable hardware. This Uno sketch uses USB serial; it does not become a native joystick merely by receiving these messages. Choose the path by your task and expand only after one complete signal path works reliably.

You do not have to take the next step alone

Cockpit Suite brings supported simulators and devices together in one software environment. The project is young, with available software and real builds already forming its foundation. Prepared combinations make setup easier where supported; a custom Arduino module remains a learning and integration project. Your reproducible experiences help improve these routes.

In the Cockpit Suite forum, share your goal, component list and last successful test. We want to help you find the next step and aim to respond the same day where possible; late questions may receive a later reply. Our workshop also covers 3D printing, CNC router work and laser projects with LightBurn. An active community in Europe and beyond helps turn individual successes into useful guidance for more cockpit builders.

Continue with your next building block