Arduino Button and LED: Blink and Fade on an Uno in Your Browser

An Arduino button and LED is the project almost everyone builds first, and for good reason: it teaches outputs, inputs and code in one small circuit. In this tutorial you will build it on an Arduino Uno in your browser, in three steps. First you blink an LED. Then you fade it. Then you add a pushbutton that switches between blinking and fading each time you press it.

Every step starts from a built-in Mokxi example, so you always have a working circuit to compare against. You do not need a board, a breadboard or any parts.

What you need

• A browser. Mokxi runs the editor, the compiler and the simulation in the tab.
• About half an hour.
• No account to start. You can open the examples and press Run signed out.

The circuit uses three parts next to the Uno: an LED, a 220 ohm resistor and a pushbutton. A resistor limits the current through the LED, so the LED and the pin are not overloaded.

Step 1: blink an LED

Open the Arduino Uno blink example and press Run. The LED on the breadboard flashes once a second.

Here is the example's code, without its comment lines:

void setup() {
  pinMode(LED_BUILTIN, OUTPUT);
}

void loop() {
  digitalWrite(LED_BUILTIN, HIGH);
  delay(500);
  digitalWrite(LED_BUILTIN, LOW);
  delay(500);
}

Every Arduino sketch has two parts. setup() runs once when the board starts. loop() runs again and again, forever.

• pinMode(LED_BUILTIN, OUTPUT) makes the LED pin an output. On the Uno, LED_BUILTIN is pin 13.
• digitalWrite(..., HIGH) turns the pin on (5 volts), and LOW turns it off.
• delay(500) waits 500 milliseconds, which is half a second.

Try it: change both 500s to 100, press Run again, and the LED blinks five times faster.

Step 2: add a button

Now open the Button and LED example. It adds a pushbutton between pin 2 and GND. Press Run, then press and hold the button with your pointer. The LED lights while you hold it.

The key line is in setup():

pinMode(BUTTON_PIN, INPUT_PULLUP);

INPUT_PULLUP turns on a pull-up resistor inside the Uno's chip. A pull-up resistor keeps the pin at a known level, HIGH, when the button is not pressed. Pressing the button connects the pin to GND, so it reads LOW. That is why the sketch checks for LOW:

bool pressed = digitalRead(BUTTON_PIN) == LOW;

It feels backward at first, but it means you only need two wires and no extra resistor: one side of the button to pin 2, the other to GND.

Step 3: fade an LED with PWM

The third example is Fade an LED. Open it and press Run, and the LED breathes up and down instead of snapping on and off.

Fading uses analogWrite(), which takes a value from 0 (off) to 255 (fully on). The Uno cannot output a true in-between voltage. Instead it uses PWM, short for pulse width modulation: the pin switches on and off very fast, and the share of time it spends on sets how bright the LED looks.

Only some Uno pins can do this. They are pins 3, 5, 6, 9, 10 and 11. That is why the fade example uses pin 9 and not pin 13. If you call analogWrite() on pin 13, the LED just snaps between off and on.

The example sketch steps through a table of brightness values shaped like a cosine curve, which looks smoother to the eye than a straight ramp. The Arduino PWM fade guide explains that curve and the Uno's PWM pins in more depth. For our combined sketch, a simple straight ramp is enough.

Step 4: wire the LED to a PWM pin

Now put it together. Start from the Button and LED example, because it already has the button and the LED wired up. You only need to move one wire.

1. Open the Button and LED example in the editor.
2. Find the green wire that runs from pin 13 to the breadboard, next to the resistor.
3. Click the wire to select it and press Delete (or Backspace).
4. Drag a new wire from pin 9 on the Uno to the same breadboard column the old wire used, so it meets the resistor's leg.

On a breadboard, each short strip of five holes is connected inside, so the new wire does not have to land in exactly the same hole. It only has to be in the same strip as the resistor's leg.

Step 5: write the blink-or-fade sketch

Replace the code in the code pane with this sketch:

// Blink or fade: press the button on pin 2 to switch the LED on pin 9
// between blinking and fading.

const int LED_PIN = 9;      // a PWM pin, so analogWrite() can dim it
const int BUTTON_PIN = 2;   // the other side of the button goes to GND

bool fading = false;        // false: blink, true: fade
bool wasPressed = false;    // the button as it was last time round
int level = 0;              // fade brightness, 0 to 255
int change = 5;             // how much the brightness moves each step

void setup() {
  pinMode(LED_PIN, OUTPUT);
  pinMode(BUTTON_PIN, INPUT_PULLUP);
  Serial.begin(9600);
  Serial.println("Mode: blink");
}

void loop() {
  bool pressed = digitalRead(BUTTON_PIN) == LOW;

  // Act only on the moment the button goes down, not while it is held.
  if (pressed && !wasPressed) {
    fading = !fading;
    Serial.println(fading ? "Mode: fade" : "Mode: blink");
    delay(20);  // give the contacts a moment to settle
  }
  wasPressed = pressed;

  if (fading) {
    analogWrite(LED_PIN, level);
    level = level + change;
    if (level <= 0 || level >= 255) {
      change = -change;  // turn round at either end
    }
  } else {
    // On for 500 ms, off for 500 ms, worked out from the clock.
    bool on = (millis() / 500) % 2 == 0;
    digitalWrite(LED_PIN, on ? HIGH : LOW);
  }

  delay(10);
}

I checked that this sketch compiles for the Uno with Mokxi's own firmware build, with warnings treated as errors.

Press Run. The LED blinks. Press the button once and it starts to fade. Press it again and it goes back to blinking. Open the Serial tab to see "Mode: blink" and "Mode: fade" each time you switch.

How the sketch works

Catching the press, not the hold

The button is read every time through loop(), which is up to about a hundred times a second. If the sketch flipped the mode whenever the button read LOW, holding it down would flip the mode over and over.

So the sketch remembers the last reading in wasPressed. It only switches when the button is pressed now and was not pressed last time. That moment is called an edge: the change from not pressed to pressed.

Blinking without delay(500)

In Step 1, delay(500) froze the whole sketch for half a second. Here that would be a problem, because a press during the wait would be missed.

Instead, the sketch asks the clock. millis() counts milliseconds since the board started. Dividing by 500 and checking whether the result is even or odd gives on for half a second, off for half a second, with the loop still running every 10 milliseconds.

Fading up and down

In fade mode, each pass writes level to the LED and adds change. When level reaches 255 or falls back to 0, change flips sign, so the brightness turns round. With steps of 5 every 10 milliseconds, one fade up takes about half a second.

Why the delay(20) after a press

Real buttons do not switch cleanly. The metal contacts bounce for a few milliseconds, which can look like several quick presses. The short delay(20) after a press lets the contacts settle. It is the simplest fix. The Arduino button debounce guide shows the bounce happening and covers better methods.

If it does not work

• The LED blinks but will not fade. Check the LED wire is on pin 9, not pin 13. Pin 13 has no PWM.
• Nothing happens when you press the button. Check one side of the button goes to pin 2 and the other to GND, and that INPUT_PULLUP is in setup().
• The LED never lights. Check the LED's anode (marked A) connects to the resistor and its cathode (marked C) goes to GND.

What to try next

• Change change from 5 to 1 for a slow, gentle fade.
• Add a third mode: hold the LED fully on. Use a number for the mode instead of true and false.
• Change the blink speed by replacing 500 with a smaller number.

Ready to build it yourself? Create your free Mokxi account and open the editor in your browser. No installs, no parts to buy.