Mood Lamp

Three new things happen here, and each one opens a door.

• Brightness. You will make a light fade smoothly instead of snapping on and off. You will also find out that the board is lying to you about how it does that, and prove it with your own hand.
• Colour. One LED that can be any colour you name, and the reason why mixing coloured light works differently from mixing paint.
• Repeating. In Band 0 you copied and pasted the same four lines over and over to get three flashes. Here you learn the tool that does that for you, and going from three to ten costs you one character.

What you need

• Your board, USB cable and breadboard
• One ordinary LED and one RGB LED. The RGB one has four legs instead of two.
• Four resistors of 220 ohms. Three are used at once in Part 7; the fourth is a spare.
• Jumper wires
• A torch, or your phone light
• Something to make a diffuser from: a ping pong ball, a plastic sachet-water bottle, or white paper

Ten minutes with a torch will teach you the main idea of this band better than any explanation.

You need a small light: a torch, or the camera light on a phone. A big room lamp will not work, because you cannot cover it with a hand.

That change-over point, where fast flashing stops looking like flashing and starts looking like dimness, is the whole trick behind this band.

The board cannot make a dim light. Its pins have only two settings: fully on at 5 volts, or fully off at 0 volts. There is nothing in between. What it can do is switch between them faster than your eye can follow, and let your eye do the averaging for it.

The instruction for this is analogWrite. You give it a pin and a number from 0 to 255.

• analogWrite(9, 0); means fully off
• analogWrite(9, 255); means fully on
• analogWrite(9, 128); means about half brightness
• analogWrite(9, 64); means about a quarter brightness

But the pin is never actually at half a voltage. Here is what it is really doing.

Look at the three lines in the picture. None of them ever sits at a middle height. They are all jumping between the top and the bottom. What changes is how much of the time is spent at the top.

This has a name: PWM. You do not need to remember what the letters stand for. What you need to remember is the idea: fast switching that your eye reads as dimness.

Only some pins can do this

This is the single most common trap in this band, so read it twice.

On an Arduino Uno, only pins 3, 5, 6, 9, 10 and 11 can do PWM.

Look at your board now. Next to those six pin numbers, and only those, there is a small squiggle printed: ~. That mark is how the board tells you which pins can dim.

Find all six squiggles on your own board before you carry on. Write the six numbers in your glossary.

int lampPin = 9;

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

void loop() {
  for (int level = 0; level <= 255; level = level + 4) {
    analogWrite(lampPin, level);
    delay(20);
  }
  for (int level = 255; level >= 0; level = level - 4) {
    analogWrite(lampPin, level);
    delay(20);
  }
}

There is one completely new thing here: the word for. Part 4 explains it fully. Before you read that explanation, make your guesses, even though you do not understand it yet. Guessing first is what makes the explanation stick.

A for loop is a way of saying: do this block of lines over and over, counting as you go, and stop when the count reaches a certain point.

Here is the first line on its own:

for (int level = 0; level <= 255; level = level + 4) {

Inside the round brackets there are three separate parts, separated by two semicolons. Each one does a different job. Look at them one at a time.

The order things happen in

Read this list slowly. It is the whole machine.

1. level is created and set to 0.
2. Test: is 0 less than or equal to 255? Yes. So run the block.
3. Block runs: analogWrite(lampPin, 0) then delay(20).
4. Step: level becomes 4.
5. Test: is 4 less than or equal to 255? Yes. Run the block again.
6. Block runs with level now 4. Then step makes it 8. Test passes. And so on.
7. Eventually level becomes 256. Test: is 256 less than or equal to 255? No. So the block does not run, and the loop is finished.

Now answer the guesses properly

How many rounds? level takes the values 0, 4, 8, 12, and so on up to 252. That is 64 different values. So the block runs 64 times.

Working it out: the last value is 252, the step is 4, so 252 divided by 4 is 63, plus one more for the very first round at 0, giving 64.

How long is one round of loop? There are two for loops, one going up and one coming down. 64 rounds each is 128 rounds altogether. Each round waits 20 milliseconds. 128 times 20 is 2560 milliseconds, which is about two and a half seconds.

What is the largest number level ever holds? It is 256, and that surprises most people. On the last round that actually runs, level holds 252. Then the step adds 4, making it 256, and only then does the test fail. So the biggest number it ever holds is one that never reaches the pin. The same thing happens in the second loop coming down, where it ends up holding −1.

Why <= and not <? <= means "less than or equal to". With < the loop would stop before ever reaching the top value. Using <= means 255 itself is allowed. This one character makes a real difference and there is a question about it at the end.

The circuit is exactly the same as Band 1, but on pin 9 instead of pin 8, because pin 9 can do PWM and pin 8 cannot.

Now prove the board is faking it

Three changes. Do them in order and watch carefully each time.

void loop() {
  analogWrite(lampPin, 60);
}

Another short activity before any code.

There are two ways to do this. The screen way needs nothing but a phone, so start there. The torch way is more fun if you can manage it.

The screen way, on your own, with one device

The torch way, if you can get two lights

You need two lights you can colour: a torch with a red sweet wrapper taped over the front and another with a green one, or two phones each showing a full screen of one pure colour.

Either way, write down the colour you get for each pair.

• Red and green together
• Red and blue together
• Green and blue together
• All three together

That is exactly what you are about to control. An RGB LED takes three numbers, each from 0 to 255, and mixes that much red, green and blue light.

To find the three numbers for any other colour, search the web for the colour name followed by "RGB value". You will get three numbers in that order.

An RGB LED looks like one light but it is really three lights inside one plastic case: a red one, a green one and a blue one, sitting right next to each other so their light mixes.

That is why it has four legs. Three of them are the three lights. The fourth is the shared return path that all three use.

Because it is three lights, it needs three resistors. Not one. This is the second most common mistake in this band.

Finding the legs

Hold the LED with the four legs pointing down. One leg is clearly longer than the other three. That is the shared one, and it goes to ground.

Now hold it so the four legs point down and the rounded back of the dome faces you, not the flat side. Turn it so that the long leg is second from the left. There will be one short leg to its left and two short legs to its right. (Which face you look from matters. Turn it round and the order reverses, so fix on the rounded back and stay there.) With it that way round, reading left to right:

Read the sketch you just ran

int redPin = 9;
int greenPin = 10;
int bluePin = 11;

void showColour(int r, int g, int b) {
  analogWrite(redPin, r);
  analogWrite(greenPin, g);
  analogWrite(bluePin, b);
}

void setup() {
  pinMode(redPin, OUTPUT);
  pinMode(greenPin, OUTPUT);
  pinMode(bluePin, OUTPUT);
}

void loop() {
  showColour(255, 0, 0);
  delay(1000);

  showColour(0, 255, 0);
  delay(1000);

  showColour(0, 0, 255);
  delay(1000);

  showColour(255, 120, 0);
  delay(1000);

  showColour(255, 255, 255);
  delay(1000);

  showColour(0, 0, 0);
  delay(1000);
}

There is something new in the middle: a group called showColour.

It looks like setup and loop, because it is the same kind of thing: a named group of instructions. But this one is not built into the Arduino. Somebody wrote it. It is called a function.

The difference from setup and loop is that this group does not run on its own. It runs only when something asks for it by name. Look at loop: every line there that says showColour(...) is asking for it.

And it takes three numbers with it. Look at the top line of the group:

void showColour(int r, int g, int b) {

The three things in the brackets are empty boxes waiting to be filled. When loop says showColour(255, 120, 0), then inside the group r holds 255, g holds 120, and b holds 0. The three analogWrite lines then use those.

The worked example

Now upload b2_03_colour_story_worked.ino. Watch it all the way through before you read it. It is a sunrise: night, first red light, orange, full daylight, then back to night.

Then open it and find the group called fadeTo. This is the part that matters:

void fadeTo(int r1, int g1, int b1, int r2, int g2, int b2) {
  for (int step = 0; step <= 100; step = step + 1) {
    int r = r1 + (r2 - r1) * step / 100;
    int g = g1 + (g2 - g1) * step / 100;
    int b = b1 + (b2 - b1) * step / 100;
    showColour(r, g, b);
    delay(stepDelay);
  }
}

One name in there comes from further up the file. Near the top of b2_03_colour_story_worked.ino is the line int stepDelay = 25;. That is the pause between the hundred small steps, and it is the one number you change to make a fade slower or faster. Find it now, so you know where it is when Part 11 asks you to change it.

It takes six numbers: the colour you are starting from, and the colour you are going to. Then it walks from one to the other in a hundred small steps, showing each one, so the change looks smooth instead of jumping.

The arithmetic inside says: start where you are, and add the part of the difference you have travelled so far. When step is 0 you get exactly the first colour. When step is 100 you get exactly the second. In between you get a mixture.

You do not need to be able to write this yet. You do need to be able to say what it does, because your Make task uses it.

a. Run the loop by hand

Take the first for loop of b2_01. Copy this table and fill it in for the first four rounds and the last one.

b. Find the one wrong character

Your board still has the RGB LED on it from Part 7, and that is fine. The wire going to pin 9 is the red channel, and red is the light this exercise uses. Leave the green and blue wires alone.

Unplug the USB cable, then move one wire. Take the wire that goes to pin 9 and put it into pin 7 instead. Plug the USB back in afterwards. Leave everything else exactly as it is.

Now open b2_04_buggy_nonpwm.ino and upload it. It compiles. It uploads. The LED is wired correctly and it does light up. But it will not fade. It snaps from off to on, somewhere in the middle.

One character in the sketch is wrong. Find it by reading, then say why moving that wire is what made the fault show up.

c. Put the lines back in order

The five lines inside fadeTo's loop have been shuffled:

delay(stepDelay);
int g = g1 + (g2 - g1) * step / 100;
showColour(r, g, b);
int b = b1 + (b2 - b1) * step / 100;
int r = r1 + (r2 - r1) * step / 100;

Put them back in a working order. Then say why the order matters, in one sentence.

d. Why is your white not white?

In b2_02, the line showColour(255, 255, 255) is supposed to give white. Look at yours carefully. It is probably slightly pink, or slightly blue, or slightly green.

Why would equal numbers not give equal light?

Work on a copy of b2_01.

Your plain LED came off the board in Part 7 and it does not go back. b2_01 uses pin 9, which is now the red channel of the RGB LED, so what you will watch fade in this part is a red light coming out of the RGB one. That is expected. Nothing is broken.

Bronze

Make the fade take exactly twice as long, without changing any delay. Count the rounds before and after to prove it worked. Then say what the two different ways of slowing it down are, and what each one costs you.

Silver

Make it breathe: hold at full brightness for one second at the top of each round, and stay fully off for two seconds at the bottom.

Gold

Rewrite b2_01 so that both the step size and the delay are names at the top of the sketch. Then retune the whole thing to a slow, smooth two second breath by editing only those two lines. After that, go back to your Band 0 Gold answer and rewrite it using a for loop. Compare the number of lines.

How to go about it

Test it on two people

Show it to two people separately. Ask each the same question: what does this remind you of?

Write down both answers word for word. If neither is close to what you intended, you have learned something more useful than a working lamp. Write down what you would change.

Show your work

Post a video of the whole story, all 45 to 90 seconds of it, not a short clip. Include both testers' answers. Then look at one other person's sketch and tell them one place where their colour numbers would be easier to change.

Code you have not seen. Answer from reading only.

int pin = 6;

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

void loop() {
  for (int v = 0; v < 200; v = v + 40) {
    analogWrite(pin, v);
    delay(250);
  }
}

1. List every value that v takes.
2. How long does one full pass through loop take?
3. Does the LED ever reach full brightness? Explain.
4. What does a person watching see at the moment loop starts again?
5. Change two numbers so the fade looks smooth instead of stepped, while one full pass still takes about the same time.
6. Would this sketch behave the same way on pin 7? Say exactly what would happen.

You can control brightness, and you know that the board is faking it, because you proved it with your own hand. You can mix any colour from three numbers. And you can write a loop that repeats itself, which means the length of your code no longer grows every time you want to do something more.

Before you move on, make sure you have

• Your finished lamp with its diffuser, and a video of the whole story
• Both testers' answers, word for word
• Your sentence about what you saw when you waved your hand
• Your completed table from Part 8a
• The six PWM pin numbers written down
• Your build log for this band
• Five or six correct answers in Part 11, including question 6

Next is Band 3: Combination Lock. So far the board has only ever talked. Next it starts listening, and you find out that a button is far stranger than it looks.