08. Functions: Naming & Reusing Tasks

Why functions matter

In Lesson 07 a for loop removed repeated lines. Functions remove repeated ideas. When the same job appears in several places - switch every LED off, flash a warning, convert a reading - give it a name and write it once.

A good function name turns loop() into something you can read aloud: chase forwards, chase backwards, flash all. When a pin or a timing changes, you edit one function and every caller follows.

Parts of a function

Every function has four parts. The return type says what comes back (void means nothing). The name says what it does. The parameter list names the values it needs. The body, inside braces, does the work.

Define the function outside setup() and loop() - never inside another function. Call it by writing its name with values in the brackets: setAll(HIGH);

void setAll(bool state) {
  for (byte i = 0; i < ledCount; i++) {
    digitalWrite(leds[i], state);
  }
}

// Called from loop():
setAll(HIGH);
setAll(LOW);

void helpers act on hardware

Most Uno helper functions do something physical and return nothing: set outputs, beep, print a status line. Parameters make one function cover several cases.

chase(bool forward, int stepMs) runs the same four-LED chase in either direction at any speed. Inside, an if chooses the index, so one loop serves both directions.

void chase(bool forward, int stepMs) {
  for (byte i = 0; i < ledCount; i++) {
    byte index = i;
    if (!forward) {
      index = ledCount - 1 - i;
    }
    digitalWrite(leds[index], HIGH);
    delay(stepMs);
    digitalWrite(leds[index], LOW);
  }
}

Returning a value

Replace void with a type when the function should hand back a result. return ends the function immediately and sends the value to the caller, so the call can sit anywhere that value fits: in an assignment, a Serial.print or an if.

Keep calculations like this free of hardware so they are easy to test - Code Along checks exactly this kind of function by calling it with known values.

int stepTime(byte level) {
  return 400 - level * 50;   // level 0 -> 400 ms, level 5 -> 150 ms
}

bool isPressed(byte pin) {
  return digitalRead(pin) == LOW;   // INPUT_PULLUP: pressed reads LOW
}

Parameters are copies; locals are temporary

A parameter receives a copy of the caller's value. Changing it inside the function does not change the caller's variable.

Variables declared inside a function are local: they are created on each call and destroyed when it returns. If a value must survive between calls - a counter, a timestamp, the last button state - declare it globally (outside every function) or pass it back with return.

Make loop() read like a plan

Large sketches stay manageable when loop() is a short list of named steps. Each step becomes a function with one job. The integration projects and assessments later in the course use exactly this shape: read inputs, decide, update outputs, report.

If you cannot name a function without the word 'and', it is probably doing two jobs - split it.

void loop() {
  readInputs();      // buttons and sensors into global variables
  updateState();     // decisions only - no pins touched here
  driveOutputs();    // LEDs, buzzer, motor
  reportStatus();    // Serial or LCD, only when something changed
}

What the worked sketch practises

setup() configures the four LED pins. loop() runs six rounds: stepTime() returns a shorter delay each round, chase() runs forwards and backwards at that speed, and Serial reports the timing. setAll() then flashes every LED together.

The chase still uses delay() so the pattern is easy to follow. Lesson 11 shows how to keep a sketch responsive while patterns run.

Wiring and safe build sequence

1. D2 -> 330 ohm -> LED anode; cathode -> GND
2. D3 -> 330 ohm -> LED anode; cathode -> GND
3. D4 -> 330 ohm -> LED anode; cathode -> GND
4. D5 -> 330 ohm -> LED anode; cathode -> GND
5. Same four-LED row as the loops lesson - no rewiring needed