Traffic Light

What it is

Three LEDs, three resistors and a header. The LEDs are small surface-mount parts stacked red, yellow and green beside a traffic light drawn in the silkscreen. Each has its own 1 kΩ resistor and its own pin, and the three share nothing but GND.

It is active high. Set a colour's pin HIGH and that light comes on, LOW and it goes out. The back of the board says so: each GPIO controls one light, HIGH turns on, LOW turns off.

Nothing on the board stops two lights showing at once, the way a real signal's controller would. The sequence lives entirely in your sketch, which is what makes this block the natural first lesson in a program that remembers what it is doing.

Three lights, three currents

There is no supply pin: each signal pin powers its own LED. The green takes about 2.7 V before it conducts and the red and yellow about 1.9 V, so the green gets less of what is left:

All of it is well within what any of these boards' pins may supply. The currents are worked out from the three LED datasheets, which give ranges, not measured on a board.

Which pin is which

LEDs up, header at the bottom, reading left to right:

The back prints TK03 TRAFFIC LIGHT and what the pins do instead of their names. Turned over, the square pad is on the right, and it is still GND.

Wiring, in four lines

1. GND to your board's GND.
2. RED to D9 on an Uno, GPIO 25 on an ESP32, GPIO 4 on an ESP32-S3, or GP13 on a Pico.
3. YELLOW to D10, GPIO 26, GPIO 5 or GP14.
4. GREEN to D11, GPIO 27, GPIO 6 on the S3, or GP15.

Leave both NC pins unconnected. No resistor to add, no library to install.

Example

// GPIO numbers. Uno: 9, 10, 11. ESP32: 25, 26, 27. ESP32-S3: 4, 5, 6.
// Pico: 13, 14, 15.
const int RED_PIN = 4;
const int YELLOW_PIN = 5;
const int GREEN_PIN = 6;

// Set all three at once, so no step can leave a light on by mistake.
void show(bool red, bool yellow, bool green) {
  digitalWrite(RED_PIN, red ? HIGH : LOW);
  digitalWrite(YELLOW_PIN, yellow ? HIGH : LOW);
  digitalWrite(GREEN_PIN, green ? HIGH : LOW);
}

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

void loop() {
  show(HIGH, LOW, LOW);   // red
  delay(5000);
  show(LOW, LOW, HIGH);   // green
  delay(5000);
  show(LOW, HIGH, LOW);   // yellow
  delay(2000);
}

from machine import Pin
import time

# GPIO numbers. ESP32: 25, 26, 27. ESP32-S3: 4, 5, 6. Pico: 13, 14, 15.
red = Pin(4, Pin.OUT, value=0)
yellow = Pin(5, Pin.OUT, value=0)
green = Pin(6, Pin.OUT, value=0)


def show(r, y, g):
    red.value(r)
    yellow.value(y)
    green.value(g)


while True:
    show(1, 0, 0)   # red
    time.sleep(5)
    show(0, 0, 1)   # green
    time.sleep(5)
    show(0, 1, 0)   # yellow
    time.sleep(2)

This is the plain red, green, yellow cycle many countries use. The UK, among others, shows red and yellow together before green; the handbook adds it as one row of a table.

Where to start

The handbook below is eight short articles, each with a working figure. The lamp test is the wiring in four wires and a sketch that proves it.

If you only read one, read a sketch that remembers. The example above waits for seconds at a time and notices nothing while it does; that article rewrites it so it never waits.

And if the green looks dim on your ESP32, why the green is different works out why that is normal.