Variables in Arduino

Learning Goals 5 min

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

1. Declare a const int at the top of a sketch and use it in place of a literal pin number wherever pinMode() or digitalWrite() appear.
2. Explain in one sentence why a named constant is safer than typing 13 in three different places.
3. Move your external LED from pin 13 to pin 9 by changing exactly one line of code and one wire — and have it still blink.

Warm-Up 10 min

Last lesson you typed 13 three times into your Blink sketch — in pinMode, in digitalWrite(13, HIGH), and in digitalWrite(13, LOW). Three copies of the same number. Today we make that number a name.

Quick-fire puzzle

Aaina has the Blink sketch open and decides she wants to move her external LED from pin 13 to pin 9. Without peeking ahead, predict:

1. How many 13s does she need to change to 9?
2. If she only changes two of them and forgets the third, what is the most likely symptom on her LED?
3. What would make this whole job easier if she had to do it ten times in a row?

New Concept 20 min

The big idea — give your numbers a name

A variable is a name that stands in for a value. Instead of typing 13 three times, you write LED_PIN three times — and decide once, at the top of the sketch, what number LED_PIN stands for. Change that single line and every use of LED_PIN changes too. This is called the single source of truth: the truth about which pin we're using lives in one place.

Two kinds of integer variable

Arduino sketches use two related types for whole numbers:

Naming conventions

• Constants get ALL_CAPS with underscores: LED_PIN, BLINK_MS, SENSOR_THRESHOLD. The capitals shout "I never change!"
• Regular variables get camelCase (first word lowercase, every later word capitalised): buttonState, readingCount, currentColour. Lowercase first letter for a "thing that can change".
• Both must start with a letter, never a digit. Never use a hyphen — it's read as "minus".

Where the constant lives in the sketch

Declarations go above setup() — in what's called the global space. Both setup() and loop() can then see them.

const int LED_PIN = 13;

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

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

The behaviour of this sketch is identical to the literal-13 version from L01-08. The hardware doesn't know the difference. Naming the pin is for your benefit — and for the benefit of every future student who reads your code.

Reuse the L01-07 wiring

Today's circuit is exactly the LED-on-D13 setup you built in L01-07. Keep it wired up. The yellow signal jumper goes from Arduino D13 to breadboard A6; the 220 Ω resistor lies in row D from D6 to D11; the red LED stands in B10/B11; the GND return runs through the breadboard's − rail back to the Arduino's GND pin.

Why it matters

Professional sketches sometimes use a dozen pins, half a dozen delay values, and a handful of thresholds. Naming every one of them at the top of the file means a colleague (or future-you) can tweak the project six months from now by editing one section, without having to read every line of the sketch.

Worked Example 20 min

Goal: convert your L01-08 Blink sketch to use a named constant, then prove the named version behaves exactly the same.

Step 1 — open your L01-08 sketch

In the Arduino IDE, open the Blink sketch you saved last lesson. It should have three copies of the number 13 inside it.

Step 2 — add the constant line

At the very top of the file, above void setup(), type:

const int LED_PIN = 13;

Then leave a blank line before void setup().

Step 3 — replace every literal 13

Replace each of the three 13s with LED_PIN. Your sketch should now look like this:

const int LED_PIN = 13;

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

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(1000);
  digitalWrite(LED_PIN, LOW);
  delay(1000);
}

Step 4 — upload and observe

Click Upload. Watch your external LED. It blinks exactly as before. The wiring didn't change. The behaviour didn't change. The Arduino can't tell that anything changed. You can — your code is now easier to read and easier to change.

Step 5 — reflect

Look at your two versions side by side (the literal-13 one from L01-08 and the named-constant one from today). Both work. Both compile. Both blink the same. So why did we bother?

• Readability: digitalWrite(LED_PIN, HIGH); reads like a sentence. digitalWrite(13, HIGH); doesn't tell you what pin 13 is.
• Changeability: Move the LED to pin 9? Edit one line. The named version protects you from forgetting one of the three replacements.
• Reusability: Tomorrow you'll wire three LEDs (L01-10). You'll want RED_PIN, YELLOW_PIN, GREEN_PIN at the top. Today is the warm-up.

Try It Yourself 20 min

Three small experiments on the named-constant Blink sketch from the Worked Example.

// Change this one line:
const int LED_PIN = 9;

// Everything below stays exactly the same.
void setup() {
  pinMode(LED_PIN, OUTPUT);
}

const int LED_PIN = 13;
const int BLINK_MS = 500;

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

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(BLINK_MS);
  digitalWrite(LED_PIN, LOW);
  delay(BLINK_MS);
}

const int LED_PIN = 13;

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

void loop() {
  LED_PIN = 9;  // ← this line should fail to compile
  digitalWrite(LED_PIN, HIGH);
}

Mini-Challenge 15 min

The "tunable beacon"

Build a Blink sketch with three constants at the top — one for the pin, one for how long the LED stays on, and one for how long it stays off. A classmate or your teacher should then be able to change the LED's entire behaviour by editing only those three lines, without ever touching setup() or loop().

Your task:

1. Pick names for your three constants. Use ALL_CAPS. For example: LED_PIN, ON_MS, OFF_MS.
2. Write the full sketch — your setup and loop should reference only constants and the Arduino built-ins (HIGH, LOW, OUTPUT). No literal numbers inside loop().
3. Upload and confirm it works.
4. Swap laptops with a partner. Their job is to change the LED's behaviour to a slow heartbeat (50 ms on, 950 ms off) by editing only the top of your sketch.

It works if:

• Your partner makes the heartbeat happen by editing exactly two lines at the top.
• Your loop() body contains zero raw numbers — only constant names.
• The sketch compiles with no red squiggles.

const int LED_PIN = 13;
const int ON_MS = 100;
const int OFF_MS = 900;

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

void loop() {
  digitalWrite(LED_PIN, HIGH);
  delay(ON_MS);
  digitalWrite(LED_PIN, LOW);
  delay(OFF_MS);
}

Recap 5 min

A variable is a name that stands in for a value. Use const int for values that don't change while the sketch runs (pin numbers, fixed delays). Use plain int for values that need to change (counters, scores). Declare them above setup(). Name constants in ALL_CAPS and regular variables in camelCase.

Variable

A name in your code that stands in for a value. Like a label on a jar that lets you talk about "what's in the jar" without describing the contents every time.

const int

A name for a whole-number value that never changes while the sketch is running. The compiler refuses to let you reassign it — a built-in safety net.

int

A name for a whole-number value that can change. Used for counters, scores and other things that need to update.

Global scope

The space at the top of the sketch, above setup(). Variables declared here are visible to both setup() and loop().

Single source of truth

The habit of writing each important value in one place in your code. Change that one place and the whole sketch updates correctly.

Homework 5 min

Name every number. Take the "name flasher" sketch you wrote for L01-08's homework (the one that flashes the LED once per letter of your first name) and rewrite it so that every number at the top is a named constant. By the end, the body of loop() should contain no literal numbers — only names like LED_PIN, ON_MS and OFF_MS.

Add a comment above each constant explaining what it stands for, like this:

// LED_PIN — which Arduino pin the external LED is wired to
const int LED_PIN = 13;

Bring back next class:

• The saved .ino file on a USB stick (call it name-flasher-named).
• A short reflection on paper (2–3 sentences): which constants did you give names to, and was there one that was harder to name than the others?
• One example of a "magic number" you spotted that you decided not to name — and your reason why. (Hint: not every number needs a name. Numbers used once in the right context can stay as literals.)