Things That Move

A light does not care. Ask it for half brightness and it gives you half brightness, instantly, every time, and it never gets tired or stuck.

A moving thing is different in two ways that will surprise you.

• It takes time to get there. You tell it a position and it starts travelling. It arrives a moment later. Nothing in your code says so, and nothing warns you.
• It needs real power. A light draws a trickle. A motor pushing something draws far more than an Arduino pin can supply. Wire it the obvious way and the obvious way is wrong.

By the end you will be able to

• Make a servo go to a position you choose, and say why it is a position and not a speed
• Bring in code somebody else wrote, using a library, and read its documentation
• Explain why a shivering reading makes a shivering arm, and stop it
• Wire two power sources together correctly, and say what happens if you do not
• Build a mechanism out of cardboard that responds to something happening in the room

What you need

• Your board, USB cable and breadboard
• An SG90 servo, the small blue one with three wires and a bag of white plastic arms
• A potentiometer, one LED, one 220 ohm resistor, one push button
• A battery pack, four AA cells, with two loose wires
• Cardboard, scissors, tape, and a skewer or a straightened paper clip
• About ten jumper wires
• Only if you are doing one of this band's Swap projects instead of the servo gate:
  • The stepper dial needs a 28BYJ-48 stepper and its ULN2003 driver board.
  • The fan needs a small DC motor, an NPN transistor (an S8050 or 2N2222; a BC547 is too small for the job), a second 220 ohm resistor for the transistor's base, and a 1N4001-type diode, which is required and not optional. If you have no diode, use the ULN2003 board in the transistor's place; the project page explains how.

Before any wiring, spend ten minutes with your hands. This part has no board in it at all, and it is the reason the rest of the band makes sense.

The servo you are about to use has exactly your problem. Holding a position is work, not rest. A long arm is much harder than a short one with the same weight on it. And when it runs short of power, it does not stop cleanly. It wobbles, exactly like your tired fingers.

Keep this paper. In Part 7 your servo will wobble, and you will have two possible reasons for it rather than none.

Take the servo out of the box. It is a small plastic block with three wires coming out of one side and a ridged stub on top. There is a small bag of white plastic arms with it.

Those white arms are called horns. Push one onto the stub now, gently, so you can see which way it is pointing. Do not screw it down, and do not turn it with your fingers. The reason is at the bottom of this part.

The idea that catches everybody

A servo is not a motor you switch on and off. You do not tell it to spin. You tell it an angle, and it goes to that angle and holds there until you tell it a different one.

So a servo is a position machine, not a speed machine. To move it slowly, you send it a long list of angles, one degree apart, with a small wait between each. The slowness comes from you, not from it.

This is the single most useful sentence in the band, so read it twice: the servo has no idea it is moving slowly. It is going as fast as it can, to a target you keep changing.

Here is the sketch you are about to run. Read it before you wire anything, and answer the four questions. Being wrong here is worth more than being right.

#include <Servo.h>

Servo gate;
int servoPin = 9;

void setup() {
  gate.attach(servoPin);
}

void loop() {
  for (int angle = 0; angle <= 180; angle = angle + 1) {
    gate.write(angle);
    delay(15);
  }

  for (int angle = 180; angle >= 0; angle = angle - 1) {
    gate.write(angle);
    delay(15);
  }
}

Now wire it

Three lines in that sketch are new, and all three are about the same idea.

The line at the top

#include <Servo.h>

This says: before you read the rest of my sketch, go and fetch the file called Servo.h and read that first. That file contains code somebody at Arduino wrote, tested, and gave away. It knows how to produce the exact signal a servo expects, which is fiddly and which you do not want to write.

A bundle of code like that is called a library. Take that line out and the word Servo means nothing, and the sketch will not compile.

The line that makes yours

Servo gate;

This makes one servo of your own and calls it gate. The name is yours to choose. Call it arm or lid or flap if that describes your build better.

If you had two servos you would write two lines, with two names, and each would be steered separately.

The two lines with a dot in them

gate.attach(servoPin);
gate.write(angle);

The dot means belonging to. Read gate.write(90) as “the write instruction belonging to gate, with the value 90”.

You have written digitalWrite(7, HIGH) many times, where the pin number is handed over every time. Here you told gate its pin once, in attach, and after that it remembers. Every later gate.write already knows which pin it is talking about.

Think of gate as a thing that remembers its own pin. You told it once. Ask it to write and it already knows where to write to. You do not need a word for this yet. You need to be able to read the dot.

A sweep is a demonstration. A sweep that answers to something in the room is a machine. The smallest step from one to the other is the potentiometer from Band 4.

Take your hand right off the knob. Do not touch the table. Listen.

This is not a fault in your wiring, and swapping parts will not fix it. Upload b6_03_buggy_jitter.ino, which is the same sketch with the printing removed so you can hear it clearly, and let us find out why.

Find the cause yourself

The fix has a name

You have built this once before. In Band 4 you used two limits with a gap between them, so a light reading wobbling on the boundary could not flap the lamp on and off. Same idea, new place, and now it gets a name.

Only move when the new angle is far enough from where you already are to be worth moving for. That gap is called a deadband, and it looks like this:

int deadband = 3;
int lastAngle = -100;

if (abs(wanted - lastAngle) >= deadband) {
  gate.write(wanted);
  lastAngle = wanted;
}

abs gives you the size of a number and throws away whether it was above or below. So abs(89 - 90) and abs(91 - 90) are both 1. You want to know how far apart they are, not which side.

lastAngle starts at −100, which is not a real angle. That is on purpose. Any first reading is more than 3 away from −100, so the arm always moves once at the start. Without it, the arm would sit wherever it happened to be until you touched the knob.

So far your servo has been running off the Arduino's own 5V pin, with nothing attached to the horn. That works. It stops working the moment the arm has a job to do.

See it fail first

Nothing is broken. The servo asked for more current than the Arduino's 5V pin can supply, and took what it could get. The voltage sagged for everyone on that pin, including the chip running your program.

This is the same thing as your tired fingers in Part 1. Not enough force available, so the position is not held cleanly.

The fix, and the trap inside the fix

Give the servo its own power. A battery pack of four AA cells goes straight to the servo's red and brown wires, instead of the Arduino.

Do exactly that and nothing works at all. The servo twitches, or buzzes, or sits there. This is where almost everybody gets stuck, and the reason is one missing wire.

You are going to build it wrong first, on purpose, and watch it fail. That takes two extra minutes and it is the difference between knowing this and having felt it.

Now a whole device. A cardboard gate that sits where the knob puts it. Press the button and it opens all the way, then closes again three seconds later. A light shows whether it is open.

Nothing in it stops for long. The only wait anywhere is the 20 thousandths of a second that settles the button, which is the debounce from Band 3. You can turn the knob while it is closing, and the button is noticed the instant you press it.

The pin plan

The light's pin wire goes in b1, not a1. The resistor leg is already in a1, and a hole takes one leg only. The five holes in a column are joined underneath, so b1 reaches the resistor perfectly well.

Build it in stages and test each one

a. Read loop first

Open b6_04 and go straight to the bottom. The whole of loop is this:

void loop() {
  checkButton();
  moveGate();
  showState();
}

Three lines, and you can say what the device does from reading them. That is not an accident and it is not decoration. It is the reason the sketch is easy to change.

Compare it with the alternative, where all of that is typed out in one long loop. Same behaviour, and you would have to read forty lines to find out what it is for.

b. Fill this in by hand

Assume deadband is 3 and lastAngle is currently 90. For each new wanted angle in order, say whether the servo moves and what lastAngle becomes.

c. Break it on purpose

In your copy of b6_04, change int deadband = 3; to int deadband = 0;. Predict what will happen, then upload.

d. The line that is easy to miss

Inside moveGate, in the branch where the gate is not open, there is a line that says openUntil = 0;. Take it out, upload, and see what happens.

This part is optional. Skip it if you have no motor and no driver board. Nothing later depends on it.

Three kinds, and what each is for

Why a motor cannot hang off a pin

An Arduino pin can supply about twenty thousandths of an amp safely. A small DC motor wants ten to twenty times that at the moment it starts turning.

Connect one straight to a pin and you are not running a motor, you are damaging a chip. It may even appear to work for a while, which is worse, because you will not know when it stopped being fine.

A driver board solves it. Think of it as a switch that your pin operates and the battery powers. The small current gives the order. The big current does the work. The two never meet.

This is the same shape as the ground rule from Part 7. Signal and power are different jobs, and the mistakes come from treating them as one.

Work on a copy of b6_04_servo_gate_worked.ino.

Bronze

Make the gate close slowly instead of snapping shut, over about a second, while the button still responds instantly during the whole close. You will need a name holding the angle it is travelling towards and a millis check that moves it one degree at a time.

Silver

Replace the knob with the light sensor from Band 4, so the gate closes as the room darkens. Then find your two thresholds by measuring, exactly as you did in Band 4, and write them in your log. Use a different number for opening and closing, so a reading that wobbles on the boundary does not flap the gate. Read the box under this list before you wire it.

Gold

Make the servo detach() whenever it has been still for two seconds, and attach() again the moment it needs to move. Then measure the difference: run the gate on batteries for ten minutes with and without it, and say what changed. This is hard for an interesting reason, and finding that reason is the task.

The test that matters most in this band

Hand it to somebody, say nothing at all, and watch. Do not explain. Do not point.

Write down how long it takes them to work out what makes it move, and what they tried first. If they never work it out, that is the finding, and it is a finding about your build rather than about them.

Show your work

Post a video of the mechanism reacting to something real, a photo of the wiring showing the ground link clearly, and your build log. Then look at one other person's mechanism and tell them one thing a stranger would misunderstand about it.

Code you have not seen. Answer from reading only. Do not upload it.

#include <Servo.h>

Servo arm;

int armPin = 9;
int knobPin = A0;
int lastAngle = 0;
int deadband = 4;

void setup() {
  arm.attach(armPin);
  Serial.begin(9600);
}

void loop() {
  int reading = analogRead(knobPin);
  int wanted = map(reading, 0, 1023, 0, 180);

  if (wanted - lastAngle >= deadband) {
    arm.write(wanted);
    lastAngle = wanted;
  }

  delay(20);
}

1. The knob is turned slowly all the way from one end to the other. Does the arm follow it the whole way?
2. Now the knob is turned slowly back again, from 180 towards 0. What does the arm do? Explain your answer using the line with deadband in it.
3. lastAngle starts at 0 here rather than at −100. Give one situation where that makes a difference you could see.
4. The board is switched on with the knob already at the far end. The arm is physically sitting at 40 degrees. What happens in the first second?
5. Somebody removes the delay(20) to make it more responsive. What actually happens to the arm, and why?
6. The servo is powered from the Arduino’s 5V pin and has a long, heavy arm on it. The sketch is exactly as above. Name two different things you might see, and say which line of code is responsible for each.

Part 12 was the real test. This is a warm-up for it, and a list to come back to. Say each of these out loud, to somebody or to yourself, without looking anything up.

• Say why gate.write(90) is a position and not a speed, and what makes a sweep slow
• Name the three servo wires and say which two must never be swapped
• Explain, to somebody who has not done this band, why an arm shivers when nothing is touching the knob
• Say what a deadband costs you as well as what it buys you
• Draw the ground link between a battery pack and an Arduino, and say what happens without it
• Say why a DC motor needs a driver board and a servo does not (only if you did Part 10)

Before this band, everything your programs did stayed inside the board or came out as light and sound. Now they push things, and that turned out to be a different kind of problem.

The code part was small. attach, write, and one if holding a deadband. Almost everything that went wrong in this band was electrical, or was a decision about when to act rather than how to act.

That is the shape of the rest of your life in this. The programs stop being the hard part surprisingly early.

Before you move on, make sure you have

• A photo of your mechanism, and a video of it reacting to something
• A photo of the wiring where the ground link between the − rail and the Arduino is clearly visible
• Your completed deadband table from Part 9b
• Your notes from the loaded-card activity in Part 1
• The three deadband values you tried in Part 9c, and which you would choose for a gate and which for a dial
• Your build log for this band
• Five or six correct answers in Part 12, including question 2

Next is Band 7: Distance and Display. The board gets a new sense, measuring how far away things are with sound you cannot hear, and it gets a screen of its own so it no longer needs a computer to tell you anything.