Don't Copy-Paste: Master Arduino Arrays & Loops with Knight Rider

Project: The Knight Rider (Clean Version)

Let’s combine Arrays and Loops to build the ultimate scanner. We will use pins 2-7.

// Day 13: Knight Rider
int ledPins[] = {2, 3, 4, 5, 6, 7}; // Our hardware map
int pinCount = 6;                   // How many LEDs?
int waitTime = 50;                  // Speed (ms)

void setup() {
  // Use a loop to set all pins to OUTPUT
  for (int i = 0; i < pinCount; i++) {
    pinMode(ledPins[i], OUTPUT);
  }
}

void loop() {
  // 1. Scan Left to Right
  for (int i = 0; i < pinCount; i++) {
    digitalWrite(ledPins[i], HIGH); // Turn On
    delay(waitTime);
    digitalWrite(ledPins[i], LOW);  // Turn Off
  }

  // 2. Scan Right to Left
  // Start at the end (5), go down to start (0)
  for (int i = pinCount - 1; i >= 0; i--) {
    digitalWrite(ledPins[i], HIGH);
    delay(waitTime);
    digitalWrite(ledPins[i], LOW);
  }
}

How it works

• Forward Loop: i goes 0 -> 5.

• When i=0, it turns on ledPins[0] (Pin 2).

• When i=1, it turns on ledPins[1] (Pin 3).

• Backward Loop: i starts at 5 and goes down (i--).

When i=5, it turns on ledPins[5] (Pin 7).

If we want to change the speed, we just change int waitTime = 50; to 20. One change updates the entire animation. This is Soft Coding.

Deep Dive: The Off-By-One Error

The most common bug you will write is this: for (int i = 0; i <= 6; i++) In our array of 6 items, the indices are 0, 1, 2, 3, 4, 5. The item at index 6 does not exist. But if you use inclusive <= 6, the loop tries to access ledPins[6]. The Arduino will read whatever random memory garbage is next to your array. It might blink a random pin. It might reset the chip. Rule: Always use < count for zero-indexed arrays. Never <=.

Advanced Challenge: The “Bounce” Logic

The code above has a small visual glitch. It hits the end (Pin 7) and then effectively hits it again immediately when the reverse loop starts. Pin 7 stays on for twice as long. Can you fix it? Hint: Adjust the start/end points of your loops.

• Forward loop: 0 to 5.
• Reverse loop: 4 to 1. (Skip the ends on the return trip).

Challenge: The “Code Golf”

Can you write the entire knight rider loop() in fewer than 10 lines? (Hint: You can put a for loop inside another for loop?) Try to make your code as small as possible. But remember: Readability is king. If your code is short but unreadable, you failed.

Advanced Academy: The Meteor Tail Effect

The Knight Rider scanner wasn’t just blinking dots. It had a “Trail”. It faded out. With digital pins (HIGH/LOW), we can’t do that. BUT… if you move your LEDs to PWM pins (3, 5, 6, 9, 10, 11), you can use analogWrite() to change brightness. Imagine an array not of pin numbers, but of Brightness Values. int brightness[] = {255, 128, 64, 32, 10, 0}; As you loop through the LEDs, you can shift these brightness values along the strip. This is complex coding (involving “Array Shifting”), but it creates a fluid, beautiful animation. This is how modern “Neopixel” LED strips work.

Deep Dive: Why does it start at Zero?

Zero-Indexing confuses everyone. Why is the first item “0”? It comes from CPU memory logic. An array is a block of memory. The variable ledPins points to the Start Address of that block. The Index is the Offset.

• ledPins[0] = Start Address + 0 steps.
• ledPins[1] = Start Address + 1 step. If we started at 1, the compiler would have to do subtraction (index - 1) every single time it accessed memory. Starting at 0 is faster for the machine. So, we humans simulate the machine.

Advanced Optimization: Loop Unrolling

Sometimes, loops are TOO slow. The computer spends time jumping back to the top of the loop. In extreme high-speed scenarios (like video generation), engineers do Loop Unrolling. Instead of:

for (int i=0; i<4; i++) { doThing(i); } They write:

doThing(0);
doThing(1);
doThing(2);
doThing(3);

It takes more memory (code space), but runs faster because there is no logic checking i < 4 every time. For regular LEDs? Don’t do this. Use the loop. Readability > Nanoseconds.

Refactoring: The “Before and After”

Let’s appreciate how much cleaner your code is. Before (Day 11 Style): If you wanted to add 4 more LEDs, you would have to:

• add 4 pinMode lines.

• add 8 digitalWrite lines to the forward loop.

• add 8 digitalWrite lines to the backward loop. After (Day 13 Style):

• Add numbers to the ledPins array.

• Change int pinCount.

• Done. The loop logic handles the rest automatically. This is Scalable Code.

The Bill of Materials (BOM)

Hardware vs Software: The Final Verdict

Let’s compare Day 10 (Hardware) and Day 13 (Software).

Software wins on flexibility. Hardware wins on cost. But for prototyping? Software is King.

Troubleshooting

• Code won’t upload? You might have used Pin 0/1. Move your LEDs to 2-7.
• One LED stays bright? You might have blocked the loop. Check your braces {}.
• It blinks randomly? Check your array indices. Are you going out of bounds?

Common Mistakes (Debugging Guide)

Even pros make mistakes with loops. Here are the classics:

• The Infinite Loop: for (int i = 0; i > -1; i++) This loop will run forever because i (0, 1, 2…) will ALWAYS be greater than -1. Result: Your Arduino freezes.

• The Off-By-One Error: ledPins[6] Remember, if you have 6 items, the last one is [5]. Accessing [6] reads garbage memory. Result: Random behavior.

• The “Slow Motion” Bug: Using delay(1000) inside a loop that runs 10 times making the whole animation take 10 seconds. Result: Boring light show.

• Variable Scope: Declaring int i inside the loop for (int i...) means you cannot use i outside that loop. It is deleted when the loop finishes.

The Engineer’s Checklist

Before you upload, ask yourself:

• Did I connect the LEDs to PWM pins if I wanted fading? (Not needed today, but soon).
• Are my resistors on the Anode or Cathode? (Either works, but be consistent).
• Did I start my loop at 0?
• Did I end my loop at < count?
• Did I remember the delay()? Without it, the LEDs blink so fast they look like they are all ON at once.

The Engineer’s Glossary (Day 13)

• Array: A data structure that holds a list of items of the same type.

• Index: The position number in an array (Starts at 0).

• For Loop: A control structure for repeating code.

• Iteration: One single pass through a loop.

• D.R.Y.: Don’t Repeat Yourself. A core coding principle.

• Increment (++): Add one to a variable.

• Decrement (--): Subtract one from a variable.

Conclusion

You have leveled up. You are no longer writing instructions line-by-line. You are writing rules. “Do this to every pin in the list.” “Run this 50 times.” You are leveraging the computer’s ability to do boring tasks quickly.

Tomorrow, we add senses. We will learn about Analog Inputs. We will hook up a Potentiometer (a knob) to control the speed of our Knight Rider scanner real-time, just like we did in Day 10… but with code.

See you on Day 14.