RGB LED Wiring

Learning Goals 5 min

By the end of this lesson you will be able to:

1. Identify the four pins of a 5 mm RGB LED — red, green, blue, and a shared common pin — by length and position, and tell at a glance whether yours is common cathode or common anode.
2. Wire either type onto a breadboard with three 220 Ω resistors (one per colour channel), one shared connection for the common pin, and three signal wires back to digital pins on the Arduino.
3. Drive each colour on and off with digitalWrite, and combine two or three channels at once to produce the seven "primary" digital colours: red, green, blue, yellow, cyan, magenta and white.

Warm-Up 10 min

Cluster B and C used three separate LEDs (red, yellow, green) for the traffic light. They worked beautifully, but they took up half your breadboard. Cluster E begins by collapsing that pile of LEDs into a single dome the size of one regular LED. Inside it: three tiny LEDs, glued back-to-back, sharing one pin. With three Arduino outputs and a little colour theory, you can paint any colour on the visible spectrum from one little component.

Quick-fire puzzle

Look at any backlit screen — your phone, your laptop, a TV. Hold a magnifying glass close to a white area. You'll see something surprising: there is no white. There are only tiny red, green and blue dots, all lit at full brightness. Your eye blends them into white from a normal viewing distance.

1. If "white" on your phone is actually red+green+blue all on, what do you think "yellow" is, in terms of those three?
2. What about "magenta" (a hot pink)?
3. And what's the only "colour" the screen makes by turning everything off?

New Concept — three LEDs in one dome 15 min

The big idea — one package, three colours, four pins

An RGB LED looks like a regular 5 mm LED from the outside, but with four legs instead of two. Inside the clear or diffused plastic you can sometimes see three tiny coloured chips arranged in a triangle. Each chip is its own LED — red, green, and blue — and each one wants its own current limit. So instead of one resistor, this part needs three.

Three colour chips × two pins each = six pins, right? No — they save space by sharing one pin between all three. That shared pin is called the common. The other three pins are the individual R, G, and B control pins.

Two flavours: common cathode vs common anode

There are two ways to share the common pin, and you need to know which one you have. Get this wrong and the LED won't light at all — or worse, it'll light "inverted" (the off bits glow and the on bits go dark).

Identifying the pins on a real RGB LED

Hold the LED with all four legs pointing down and the flat side of the dome facing you. From this angle, the longest leg is always the common pin. The standard pinout (followed by almost every hobby-grade RGB LED from kit shops) is:

1. Leg 1 (short) — Red
2. Leg 2 (longest) — Common
3. Leg 3 (short) — Green
4. Leg 4 (short) — Blue

So with the common leg as your reference, Red is the leg before it (one step left) and Green and Blue are the two legs after it. Worth double-checking against your kit's datasheet if you have one — a small number of brands flip Red and Blue.

The "which type do I have?" test

If the bag didn't say, you can find out in 30 seconds with one resistor and the Arduino's 5 V and GND pins:

1. Put a 220 Ω resistor in series with the common leg.
2. Touch the other end of the resistor to +5 V. Touch each colour leg in turn to GND through a wire.
3. If the colour lights: you have a common anode LED (current flows in through the common, out through the colour pin to ground).
4. If nothing lights: swap the connections — common to GND through the resistor, colour pins to +5 V. If they light now, you have a common cathode.

That's it. Five seconds per pin, all three colours tested, you know exactly which type you have. Most kits sold for Arduino starter packs are common cathode — but always check.

The three-resistor rule

Don't try to save a part by using only one resistor on the common pin. The three LEDs inside have different forward voltages (red is around 2 V, green and blue closer to 3 V) and different ideal currents. A single shared resistor would let one channel hog all the current, washing out the others. One 220 Ω resistor per colour channel, always. This is also why a tidy RGB circuit looks slightly busier than the three-LED rig from L01-15 — same number of resistors, but all bunched at one component.

Why it matters

The RGB LED is the smallest version of the same trick that powers every full-colour display on the planet — phones, TVs, monitors, LED strips, stage lighting, even the screen you're reading this on. The differences are only of scale (millions of pixels instead of one) and brightness control (PWM levels instead of on/off, which is L01-31's job). Master the wiring of one RGB LED today, and you understand the foundation of every colour-mixing system.

Worked Example — wire it and cycle the colours 20 min

You're going to wire your RGB LED, identify which type you have, write a sketch that cycles each colour on and off, and finally show all seven combinations of the three channels.

Step 1 — Identify your LED

Run the "which type?" test from the New Concept. Find your longest leg (the common). Probe each colour against +5 V and GND with a 220 Ω resistor in series. Write down on a sticky note: common cathode or common anode. The rest of this lesson assumes common cathode (the kit default); if yours is common anode, you'll invert every HIGH/LOW in the sketches — note that for now and we'll address it in the questions.

Step 2 — Wire the breadboard

Pick a quiet patch of the breadboard with at least seven free columns. The RGB LED's four legs straddle the trough across rows E and F, like the buttons in L01-16 — but with all four legs in one row, not two-and-two. Pop it in so the legs land in adjacent columns; you'll get one full column per leg in rows A–E (above the trough) for the colour resistors and signal wires.

Step 3 — The "primary digital colours" sketch

With three on/off channels there are exactly 2 × 2 × 2 = 8 possible combinations, including all-off ("black"). That gives us seven visible "colours" — the corner colours of the RGB cube — which is what we'll cycle through today.

// RGB LED — cycle the seven digital primary colours
const int RED_PIN   = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN  = 11;

void setColour(int r, int g, int b) {
  digitalWrite(RED_PIN, r);
  digitalWrite(GREEN_PIN, g);
  digitalWrite(BLUE_PIN, b);
}

void setup() {
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  setColour(HIGH, LOW,  LOW);   delay(600);   // red
  setColour(LOW,  HIGH, LOW);   delay(600);   // green
  setColour(LOW,  LOW,  HIGH);  delay(600);   // blue
  setColour(HIGH, HIGH, LOW);   delay(600);   // yellow (R+G)
  setColour(LOW,  HIGH, HIGH);  delay(600);   // cyan (G+B)
  setColour(HIGH, LOW,  HIGH);  delay(600);   // magenta (R+B)
  setColour(HIGH, HIGH, HIGH);  delay(600);   // "white" (all three)
}

Step 4 — Upload and watch the colour cube

1. Upload the sketch. The LED should cycle: red → green → blue → yellow → cyan → magenta → white → red…
2. The white isn't a pure white — it's a slightly pinkish or bluish white depending on which chip in your LED is strongest. That's normal at full-brightness digital control; PWM in L01-31 will let you balance it properly.
3. If the cycle looks wrong — for example, "red" looks blue and "blue" looks red — you've probably mis-identified the pins. Swap your D9 and D11 wires to fix it without touching the code.
4. If every colour is on at the wrong moment (off when you expect on, and vice versa), you have a common-anode LED but you wired it as common-cathode. Two options: (a) move the common leg from GND to +5 V and swap every HIGH/LOW in the sketch, or (b) use a quick helper:

   void setColour(int r, int g, int b) {
     digitalWrite(RED_PIN, !r);     // invert for common anode
     digitalWrite(GREEN_PIN, !g);
     digitalWrite(BLUE_PIN, !b);
   }

   Now the rest of the sketch still reads "HIGH means on" — the helper hides the inversion.

Trace the cube on paper

The eight combinations of three on/off bits map cleanly to colour names. Fill in the table — work it out from the worked example or from your knowledge of light mixing.

If you can fill in all eight rows, you've understood the digital "colour cube" — the foundation for L01-31's smooth PWM mixing.

Try It Yourself — three RGB sketches 20 min

const int RED_PIN   = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN  = 11;

void setColour(int r, int g, int b) {
  digitalWrite(RED_PIN, r);
  digitalWrite(GREEN_PIN, g);
  digitalWrite(BLUE_PIN, b);
}

void setup() {
  Serial.begin(9600);
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
  Serial.println("Colours: r g b y c m w k");
}

void loop() {
  if (Serial.available() > 0) {
    char ch = Serial.read();
    switch (ch) {
      case 'r': setColour(HIGH, LOW,  LOW);  break;
      case 'g': setColour(LOW,  HIGH, LOW);  break;
      case 'b': setColour(LOW,  LOW,  HIGH); break;
      case 'y': setColour(HIGH, HIGH, LOW);  break;
      case 'c': setColour(LOW,  HIGH, HIGH); break;
      case 'm': setColour(HIGH, LOW,  HIGH); break;
      case 'w': setColour(HIGH, HIGH, HIGH); break;
      case 'k': setColour(LOW,  LOW,  LOW);  break;
    }
  }
}

Mini-Challenge — the colour-cube cycler 10 min

"Hit every corner of the cube, in order"

The eight combinations of three on/off bits are the eight corners of a "colour cube". Build a sketch that cycles through all eight, printing the colour name to the Serial Monitor with each step, in exactly this order: black → red → green → blue → yellow → cyan → magenta → white. Each step lasts 800 ms.

Your task:

1. Reuse setColour(r, g, b).
2. In loop(), eight pairs of "call setColour + print name + delay" — but find a way to avoid copy-pasting the same three lines eight times. Hint: think about extracting "show one colour for 800 ms" into a helper.
3. The Monitor should print:

   BLACK
   RED
   GREEN
   BLUE
   YELLOW
   CYAN
   MAGENTA
   WHITE

   …then repeat from BLACK forever.

It works if:

• The LED visibly hits all eight states in order, and the Monitor names match each one.
• Your loop() body has only one call per step (not three) — proof that the helper is doing the work.

// Colour-cube cycler
const int RED_PIN   = 9;
const int GREEN_PIN = 10;
const int BLUE_PIN  = 11;

void setColour(int r, int g, int b) {
  digitalWrite(RED_PIN, r);
  digitalWrite(GREEN_PIN, g);
  digitalWrite(BLUE_PIN, b);
}

void show(int r, int g, int b, const char* name) {
  setColour(r, g, b);
  Serial.println(name);
  delay(800);
}

void setup() {
  Serial.begin(9600);
  pinMode(RED_PIN, OUTPUT);
  pinMode(GREEN_PIN, OUTPUT);
  pinMode(BLUE_PIN, OUTPUT);
}

void loop() {
  show(LOW,  LOW,  LOW,  "BLACK");
  show(HIGH, LOW,  LOW,  "RED");
  show(LOW,  HIGH, LOW,  "GREEN");
  show(LOW,  LOW,  HIGH, "BLUE");
  show(HIGH, HIGH, LOW,  "YELLOW");
  show(LOW,  HIGH, HIGH, "CYAN");
  show(HIGH, LOW,  HIGH, "MAGENTA");
  show(HIGH, HIGH, HIGH, "WHITE");
}

Recap 5 min

An RGB LED is three regular LEDs glued together inside one dome with one shared pin. Two flavours: common cathode (shared pin to GND, drive each colour HIGH to light it) and common anode (shared pin to +5 V, drive each colour LOW to light it — inverted). The longest leg is the common; the other three are R, G, and B in standard order. Use three 220 Ω resistors, one per channel — never one shared. With only HIGH/LOW you can already paint seven visible colours plus black; PWM in L01-31 unlocks the rest of the spectrum.

RGB LED

A single 4-pin LED package containing three colour chips — red, green and blue — sharing one pin. The 5 mm hobby version is the same physical size as a standard LED but with twice the legs.

Common cathode

An RGB LED whose shared pin is the negative end of all three internal LEDs. Wire that pin to GND; drive each colour pin HIGH to light it. The kit-default flavour.

Common anode

An RGB LED whose shared pin is the positive end. Wire that pin to +5 V; drive each colour pin LOW to light it. Logic is inverted compared to common cathode.

Common pin

The shared leg of an RGB LED. Always the longest of the four legs on a standard hobby part.

Three-resistor rule

Each colour channel needs its own current-limiting resistor (typically 220 Ω). One shared resistor on the common pin gives unbalanced colours and is a real-world bug.

Digital primary colours

The eight combinations of three on/off channels: black, red, green, blue, yellow, cyan, magenta, white. The "corners" of the RGB colour cube. Today's full palette without PWM.

Homework 5 min

The single-LED traffic light. Replace the three separate-LED traffic light from L01-15 with one RGB LED. The behaviour stays the same — red for 3 seconds, then green for 3 seconds, with a yellow blink in between — but it all happens in one dome.

1. Use your worked-example wiring (R on D9, G on D10, B on D11).
2. Use setColour(r, g, b) as the helper.
3. Cycle: 3 s red → 1 s yellow → 3 s green → 1 s yellow → repeat.
4. The yellow blink uses HIGH, HIGH, LOW. You're getting yellow "for free" from the dome's mixer — no third physical LED needed.

Also: a design reflection on paper.

• How many physical components does the RGB version use compared to the L01-15 version? Count: LEDs, resistors, wires (rough estimate). ____
• What's worse about the RGB version? Think about what happens if the LED fails, what happens if one colour is brighter than another in your part, and how easily you can see each colour from across the room. ____
• If you had ten LEDs to wire (a long ten-position progress bar, say), would you reach for ten separate LEDs or ten RGB LEDs? Why? ____
• Look closely at your RGB LED in a dark room while it's running. Can you see the three separate chips inside the dome? Where are they positioned relative to each other? ____

Bring back next class:

• The saved .ino file (call it rgb-traffic-light).
• A 15-second phone video showing one full red → yellow → green → yellow cycle.
• Your four written reflection answers, in your notebook.

Heads up for next class: L01-31 "Mixing Colours" finally introduces analogWrite() — instead of HIGH/LOW (two values per channel), each colour now accepts a number from 0 to 255. That's 256³ = over 16 million possible colours from the same RGB LED you wired today. Today's seven-colour cube becomes a fully painted sphere.