Build a Servo-Powered Flip-Dot Display That Goes "Clack!"

Make your own mini wall of physical pixels — tiny flaps flip back and forth with a satisfying click to draw shapes and letters, all controlled by an Arduino Mega.

🎓 Intermediate ⏱️ 3-5 Hours 🔧 Multiple Servos 💻 Arduino Mega Code

📋 What's Inside This Project

1. How a Flip-Dot Display Works
2. Materials You'll Need
3. Wiring the Circuit
4. Step-by-Step Build
5. The Arduino Mega Code
6. Drawing Your First Shape
7. Cool Upgrades to Try

1How Does a Flip-Dot Display Work?

A real flip-dot display (you may have seen them on old buses!) is made of tiny discs that are dark on one side and light on the other. A magnet flips each disc to show one color or the other, building up letters and pictures out of physical pixels.

Our DIY version uses something every young maker already understands: tiny servo motors. Each "pixel" is a small flap glued to a servo arm. When the servo rotates one way, the dark side of the flap shows. Rotate it the other way, and the light side flips into view — with a little mechanical clack each time!

A 5×5 grid of flip-dots can already draw simple shapes like this "X" pattern!

Fun fact: Because each flap only needs two positions, the servo doesn't even need to be precise — it just needs to swing fully one way, then fully the other. That makes this a great beginner-to-intermediate mechanical project!

2Materials You'll Need

This example builds a small 3×3 flip-dot grid (9 pixels) — enough to form simple shapes and a few letters. You can scale it up later with the same idea.

1× Arduino Mega 2560

9× SG90 Micro Servo Motors

9× Small flap pieces (cardstock or foam board)

1× External 5V power supply (for servos)

1× Large breadboard or perfboard

— Jumper wires

1× Wooden or foam-core frame (3×3 grid)

1× Push button (to trigger pattern changes)

1× Hot glue gun (adult supervised)

Why an Arduino Mega? The Mega has way more pins than an Uno, which makes it perfect for controlling many servos at once — one for every flip-dot pixel!

3Wiring the Circuit

Servo Power (important!)

Nine servos moving together can pull more current than the Arduino's onboard 5V pin can safely supply. Power the servos from an external 5V supply, and connect its ground to the Arduino's GND so they share a common reference.

Servo Signal Pins

Pixel (Row,Col)	Arduino Mega Pin
1,1 / 1,2 / 1,3	22, 23, 24
2,1 / 2,2 / 2,3	25, 26, 27
3,1 / 3,2 / 3,3	28, 29, 30

Push Button

Button Pin	Connects To
Leg 1	Arduino Pin 2
Leg 2	Arduino GND

Safety first: Always connect the external power supply's ground to the Arduino's ground (a "common ground"), and ask an adult to help with the power wiring and hot glue gun.

4Step-by-Step Build Instructions

1

Cut nine small flaps. Use cardstock or foam board, about 3cm × 3cm each. Color one side dark and leave the other side light.

2

Glue each flap to a servo arm so the flap stands upright and can swing fully into view or fully out of view.

3

Mount the nine servos into your frame in a neat 3×3 grid, with even spacing between each pixel.

4

Wire each servo's signal wire to its Arduino Mega pin from the table above, and connect all servo power/ground lines to the external supply.

5

Connect the push button to Pin 2 and GND so you can trigger the next pattern with a single press.

6

Plug everything in — Arduino to your computer via USB, external power supply to the wall — and you're ready to upload code!

5The Arduino Mega Code

This code controls all nine servos as a 3×3 grid. Each pattern is stored as a simple list of on/off values, so you can design your own shapes by editing the array. Pressing the button moves to the next pattern.

// Servo-Powered Flip-Dot Display (3x3 grid)
// Each servo flips a flap between "off" (light) and "on" (dark)

#include <Servo.h>

const int ROWS = 3;
const int COLS = 3;
const int NUM_PIXELS = ROWS * COLS;

Servo pixels[NUM_PIXELS];
const int servoPins[NUM_PIXELS] = {22, 23, 24, 25, 26, 27, 28, 29, 30};

const int OFF_ANGLE = 0;   // light side shows
const int ON_ANGLE  = 90;  // dark side shows

const int buttonPin = 2;

// Patterns: 1 = flap ON (dark), 0 = flap OFF (light)
const int patterns[][NUM_PIXELS] = {
  {1,0,1, 0,1,0, 1,0,1}, // X shape
  {1,1,1, 1,0,1, 1,1,1}, // O shape (box)
  {0,1,0, 0,1,0, 0,1,0}, // I shape (line)
  {0,0,0, 0,0,0, 0,0,0}  // all clear
};
const int numPatterns = 4;
int currentPattern = 0;

void setup() {
  for (int i = 0; i < NUM_PIXELS; i++) {
    pixels[i].attach(servoPins[i]);
  }
  pinMode(buttonPin, INPUT_PULLUP);
  showPattern(0);
}

void loop() {
  if (digitalRead(buttonPin) == LOW) {
    currentPattern = (currentPattern + 1) % numPatterns;
    showPattern(currentPattern);
    delay(400); // simple debounce
  }
}

void showPattern(int patternIndex) {
  for (int i = 0; i < NUM_PIXELS; i++) {
    int targetAngle = patterns[patternIndex][i] == 1 ? ON_ANGLE : OFF_ANGLE;
    pixels[i].write(targetAngle);
    delay(60); // stagger the flips for a nice ripple "clack" effect
  }
}

Why stagger the flips? Moving every servo at the exact same instant looks robotic and the clacks blur together. A tiny 60-millisecond delay between each pixel creates a satisfying ripple of clicking sounds across the display, just like a real flip-dot sign!

6Drawing Your First Shape

1. Upload the code to your Arduino Mega.
2. Watch the grid flip into its first pattern automatically.
3. Press the button to ripple-flip into the next shape.
4. Listen closely for the clack-clack-clack as each pixel flips!
5. Open the code and edit the patterns[] array to design your own pictures, like a heart, a smiley face, or your initials.

7Cool Upgrades to Try Next

• Go bigger: Scale up to a 5×5 or 8×8 grid using all the extra pins on the Mega.
• Add scrolling text: Write code that flips through letter patterns to spell out messages.
• Add a microphone: Make the display react and flip in rhythm to sound or music.
• Bluetooth control: Add a Bluetooth module so you can send new patterns from a phone app.

Built your own clacking pixel wall? Show it off and try designing new shapes — every flip is a tiny piece of engineering! 🔲🔳