Compose a tiny tune

A melody needs pitch and rhythm. This lesson uses a short original phrase, with a deliberate rest in the middle. You will learn to pair two arrays, step through them, and leave space between notes.

Look at notes and lengths. Which note should last longest? Which entry should be silent?

Before you begin

Before running: arrays start at index 0. notes[i] and lengths[i] form a pair. A loop increments i after its body; return exits a function. newPress returns true once for an accepted press.

Your goal: Index arrays safely over time. Show this with a prediction, a tested change and an explanation using the program’s names.

Retrieve one idea: what input, state or output did you change in the previous project?

Need a reminder? Turn the dial to bend a note.

The sounder is on D3 and its jumper must be fitted. D7 starts the tune. No external wiring or music library is required. The complete frequency and duration lists are included in the sketch.

The value at index 0 in notes is paired with index 0 in lengths. The same rule applies to every later index. NOTE_COUNT comes from the array size, so the loop knows when to stop.

A note sounds for 85 percent of its time slot. The remaining 15 percent separates it from the next note. The zero-frequency entry creates a full rest without asking tone to play zero hertz.

Read this part of the actual starter

void loop() {
  const unsigned long now = millis();
  const bool pressed = newPress(now);
  if (pressed && !playing) {
    playing = true;
    noteIndex = 0;
    startNote(now);
  }
  if (playing && now - noteStartedAt >= lengths[noteIndex]) {
    ++noteIndex;
    if (noteIndex >= NOTE_COUNT) {
      playing = false;
      noTone(BUZZER_PIN);
    } else {

notes[] and lengths[] are paired arrays; zero represents a rest. noteIndex selects corresponding elements. sizeof(notes)/sizeof(notes[0]) counts elements. startNote sets the timestamp; the loop advances only once the note duration has elapsed.

Work through one case

Index 0 selects 262 Hz and 180 ms. Tone lasts 180 × 85 / 100 = 153 ms, leaving 27 ms articulation. At index 4 the note is zero, so the program waits through a rest.

Your turn: complete the trace

Index 0 selects 262 Hz for 180 ms; index 4 selects ___ and therefore plays a ___.

If your answer differs

Trace the boundary test before looking up another array entry.

Change the second frequency from 330 to 349 and listen to that one difference. Next, lengthen the rest from 120 to 300 milliseconds. Finally, add a note and its matching duration to both lists.

Use these approximate frequencies as a palette: C=262, D=294, E=330, F=349, G=392, A=440, B=494 and the next C=523 hertz. Write a new short phrase of your own instead of copying a recorded song.

Run a controlled experiment

Compose five entries including a rest. Keep both arrays the same length and trace the last index to prove the code stops before reading past the end.

1. Save a copy of the working starter. Reset the board so stored state begins from the declared values.
2. Write the expected result before editing. Change only the named factor; keep wiring and other settings fixed.
3. Edit the C++ in the editor, Verify, then Upload to the connected Uno. The starter simulation does not execute your edited C++.
4. Repeat the same input sequence. Record input, expected output, observed output and an explanation. Use labelled serial values where the sketch provides them.
5. If the result differs, inspect the relevant condition and pin before changing another factor. Restore and upload the saved starter to recover.

Core task: explain one changed case. Optional extension: choose a boundary or timing case and justify the extra test. Use a paper trace or annotated screenshot when physical manipulation is inaccessible; distinguish predictions from measurements.

Explain why changing a frequency changes pitch while changing its matching duration changes rhythm. Demonstrate a rest and a long final note.

• “Match every note with a length”: the two arrays have different numbers of entries. Add or remove the missing partner.
• There is silence throughout: check the jumper and use D7.
• One note disappears: a zero is a rest; an extremely short duration may be hard to hear.

Independent check — try before revealing

The final note starts at 2000 ms and lasts 420 ms. At 2420 ms, what prevents an out-of-range next note?

Arrays start at zero. The final valid index is NOTE_COUNT minus one. Study the array bridge and debounce helper before changing playback.

If your explanation missed a condition or stored value, add that column to your trace and try a new input. A working upload alone does not answer this check.