Programming Things That Sense and Move

A washing machine can follow a program without a keyboard. Its computer is hidden inside the machine. You can program a small board to control things too.

A program reaches the real world

Physical computing means programming a device that senses and acts. It might notice movement, light an LED, or turn a wheel. An embedded computer is built into a larger machine. Traffic lights, microwave ovens, and robot vacuums have embedded computers.

A microcontroller is a tiny computer on one chip. It stores a program and runs its instructions. A microcontroller board holds that chip and places to connect parts. Classroom boards often have buttons, lights, and sensors already attached. A micro:bit is one example.

Two kinds of parts work together

Changing software can change what the same hardware does. One board might blink a heart today and count shakes tomorrow. The board still needs the right connected parts. Instructions to move a gate cannot move it without a motor.

Follow an automatic door

Imagine walking toward a store's automatic door.

1. A sensor notices that someone is near.
2. The computer follows its program and chooses to open.
3. A motor slides the door open.
4. When nobody is near, the program waits, then closes it.

The sensor does not slide the door itself. Each part has its own job. A person chose the rules and wrote the program. The computer follows those instructions, including any mistakes in them.

When a machine acts like a robot

A robot can sense, decide, and act by following a program. A car that detects a wall and steers away does this. A toy car driven only by your remote follows your choices. Its movement alone does not show that it senses its surroundings.

Look for the job a machine does, not a screen. A washing machine's hidden computer still runs instructions, even when its only display is a few lights.

A device works because its parts share a job. You can follow the information through it in three stages: input, process, output.

What goes in, what happens, what comes out

An input gives the computer information. A button press or a light reading can be an input. An input device collects that information.

Processing happens when the computer follows the program. It might compare a reading with a number and choose an action. An output is the action it controls, such as a beep. A speaker, display, or motor is an output device.

For a reading of 12, the check is true. The program switches the LEDs on. For a reading of 95, the check is false. The program switches them off. The reading supplies information; the program gives that information a meaning.

Remember information

Storage lets the computer keep its program and values. A step counter keeps a count between movements. Without remembering the earlier count, it could not add the next step to it.

Some memory holds values only while a program runs. A board can also keep its downloaded program for the next start. Saving a program and keeping a running count are different jobs for storage.

People stay involved

At a crosswalk, your button press is an input. The program waits and changes signals in order. The signal lights and beeps are outputs. People also choose timings, write the program, and turn systems on or off. A useful device gives people clear controls, such as a stop button.

A part's role depends on what it does in that system. Light leaves an LED as output. That light can reach a sensor as input to another system.

Follow information, not power

A battery supplies power; it does not measure the world. Wires connect parts and carry power or signals. In a wired button, the button collects the input. Its wire carries that signal to the board. Ask, "Which part tells the computer something?" to find the input device.

A light can show a message without making a sound. Your program controls when it shines and how long the message stays visible.

Show a picture or a number

An LED, or light-emitting diode, is a small light. Some boards have a grid of LEDs as a display. The micro:bit has 25 LEDs arranged in five rows of five. The display can show icons, numbers, or scrolling words.

A shown heart stays until another instruction changes or clears it. Turning an LED on does not make it turn off later. Put an off instruction in the program when you want darkness.

Give your eyes time

A computer can change a light too quickly to see clearly. A pause makes the program wait. Many pause blocks use milliseconds, written ms. There are 1,000 ms in one second. A pause of 500 ms lasts half a second.

Build a blink in this order:

1. Turn the LED on.
2. Pause for 500 ms.
3. Turn the LED off.
4. Pause for 500 ms.

The first pause holds the light on. The second holds it off. Put all four blocks inside a loop to keep blinking. If you only pause after turning it off, the on part may be too short to notice.

Make a model traffic light

Use separate green, yellow, and red LEDs. Start with all three off. Repeat these steps:

• Green on; pause 5,000 ms; green off.
• Yellow on; pause 2,000 ms; yellow off.
• Red on; pause 5,000 ms; red off.

One cycle takes 12 seconds: five, then two, then five. Switching off each light keeps the next stage clear. A pattern placed only in "on start" runs once. Put it in "forever" when it must keep cycling.

Choose colors

Some colored LEDs mix red, green, and blue light. Red and green at full brightness make yellow. All three at full brightness make white. A plain single-color LED cannot change its color just because you choose a new color block. Choose an output that can show the message you need.

A beep can confirm a button press. A tune can celebrate a win. A speaker or buzzer turns your program's sound instructions into an output.

Change pitch and length

Pitch is how high or low a sound seems. You choose a tone's frequency in hertz, written Hz. A higher frequency produces a higher-pitched tone. Middle C is about 262 Hz. The A above it is 440 Hz.

Duration means how long a sound lasts. A program can set duration in beats or milliseconds. A tune is a sequence of notes, with a pitch and duration for each. A higher pitch does not mean a longer note. Change the duration to change its length.

Program a doorbell

Put these instructions in "on button A pressed":

1. Play 523 Hz for one beat.
2. Play 392 Hz for one beat.

The first sound is higher. The second is lower, giving a "ding-dong" pattern. Each press plays the sequence once. Some boards have a speaker built in. Others use a connected speaker or buzzer.

Choose when the next block runs

Suppose a two-second sound comes before "show star". With "play until done", the star appears after the sound. With "play in background", the star can appear during it. Read the block's name when matching a light to a sound.

Keep signals useful

Use a short, soft sound for "OK". Use a repeating warning only while the warning is needed. A sound in an unconditional forever loop starts again every round. Give the alarm a condition or a control that silences it.

Start with low volume and short sounds when you test. Nearby classmates need to hear their own work too.

A wheel needs to keep spinning. A model gate needs to move to a chosen position. These jobs need different kinds of motor control.

Spin or turn to a position

A motor makes movement. An output that moves something is an actuator. With a spinning motor, you can choose direction and speed. Many kits use a percentage for speed: 100% is full speed, 50% is about half speed, and 0% is stopped.

A servo turns to a position and holds it. Many classroom servos accept angles from 0 to 180 degrees. The angle tells the servo where to point, not how long to spin.

Open and close a model gate

Suppose the gate is closed at 0 degrees and open at 90 degrees. Set it to 0 in "on start". In "on button A pressed", place:

1. Set servo to 90 degrees.
2. Pause for 5,000 ms.
3. Set servo to 0 degrees.

The gate stays open for five seconds, then closes. Removing the last instruction leaves the servo holding the open position. A pause by itself does not close the gate.

Steer a buggy

A buggy can have one motor on each side. Both sides forward at matching speeds drive it straight. Both backward make it reverse. If the right wheel stops while the left moves forward, it turns right. It turns toward the slower side.

Test which direction moves your model forward. A motor's mounting can change the result. If it turns the wrong way, change the direction in the program.

Plan the whole movement

Include a stop instruction for a spinning motor. Starting it and then waiting leaves it running throughout the wait. For a three-second journey, start, pause 3,000 ms, then stop.

Follow the kit's motor connections and power setup. Motors may need an extra motor board. Keep fingers, hair, and loose clothes away from spinning parts. Support a buggy during a table test so it cannot drive over the edge.

A button tells your program whether it is pressed. Choosing how to read it changes what your device does when someone holds it down.

Two states, different switches

A button has two states: pressed and not pressed. A push-to-make switch, like a doorbell button, connects only while pressed. A toggle switch stays where you put it until you flip it again.

Buttons let people control a device. One button could choose a game mode. Another could clear a display or silence a sound.

Once per press or while held?

An event block responds when something happens. In a quiz buzzer, "on button A pressed" can show a happy face and play one beep. Button B can clear the screen. Holding A does not turn its event into a repeating loop.

A condition asks about the button's state at that moment. To run a fan while A is held, use a forever loop:

forever:
  if button A is pressed:
    motor on
  else:
    motor off

The loop keeps asking. When you release A, the next check takes the else path. Without "motor off", the fan can keep spinning after release.

Count presses carefully

If "change score by 1" sits in a button event, one press adds one. If it sits inside a fast loop's held-button check, one long hold can add many points. Every round finds the button still pressed and adds again.

A check in "on start" has a different problem. It checks only when the board starts. A press several seconds later arrives after that check has finished.

Touch can be input too

Some boards can detect buttons A and B together. Others also offer a touch-sensitive logo or pins. With a suitable kit, foil or fruit connected by clips can become touch pads. A touch pad gives the program input; the display or sound is the output that responds.

A sensor turns something in the world into a reading. Before choosing what your device should do, find out what those numbers mean in its real location.

Match the sensor to the job

An accelerometer measures acceleration, including the effect of gravity. A board uses this information to detect movement and tilt. Blocks such as "on shake" use that sensor's readings.

Read numbers before choosing a rule

On a micro:bit, light readings run from 0 for dark to 255 for bright. The sensor supplies a number, not the word "dark". A program compares that number with a threshold to choose an action.

Try this for a night light:

1. Show the light reading while the room is bright: about 140.
2. Cover the sensor and read again: about 15.
3. Choose a threshold between them, such as 50.
4. Use "light level < 50" to decide when to shine.

The reading 15 is below 50. The reading 140 is above it. A threshold of 5 would miss both situations, so the light would never come on during these tests.

Expect small changes

Readings might wobble from 140 to 142 to 139. Small changes are normal. A threshold right beside those values can make an output switch back and forth. Choose a value with space between the usual readings for your two situations.

The same threshold may fail somewhere else. Sunlight near a window can reach a partly covered sensor. Check it where the finished device will sit.

Temperature needs a little care

Classroom boards commonly report temperature in degrees Celsius, or °C. Water freezes at about 0 °C; a classroom might be near 20 °C. Some boards measure inside their computer chip. That chip can warm up while running, so its reading can be warmer than the surrounding air. A reading tells you what that sensor measured, in that place.

A board can remember information while your program runs. A variable is a named place in memory that holds a value you can change.

Build a step counter

Name a variable "steps". Put "set steps to 0" in "on start". Add these events:

• On shake: change steps by 1.
• On button A pressed: show the value of steps.
• On button B pressed: set steps to 0.

After three shakes, steps holds 3. Button A shows 3. Button B clears the count. The word "steps" is the name; 3 is the value. "Show text steps" displays the name, not the count.

Keep the starting instruction out of forever. Resetting steps every round erases the count again and again. Test by walking exactly 20 steps. A display of 26 means extra movements were counted; 14 means some steps were missed. Try changing where you wear it or how strong a shake must be.

Save a moment

"Set temp to temperature" saves the reading now. If temp becomes 21, it stays 21 until another instruction changes it. It does not follow the sensor by itself.

To keep the highest reading, begin with the first reading. For each new value, use:

if reading > highest:
  set highest to reading

With readings 21, 23, and 22, highest starts at 21. It changes to 23 because 23 is larger. It stays at 23 when 22 arrives.

Make a setting adjustable

A variable can hold a threshold too. Start threshold at 50. Button A adds 10; button B subtracts 10. Compare light with the variable threshold. Someone can tune the night light without changing its blocks.

If the comparison still contains a fixed 50, changing the variable will do nothing.

Save readings over time

A data logger collects and saves readings at regular times. Taking a reading every five seconds for one minute gives 12 readings, when the first is at five seconds. A table or graph can show how they changed.

Choose the gap to match the change. Moving a board happens quickly, so readings need to be close together. A room cooling overnight changes slowly, so a gap of several minutes can work.

A room can become darker after a board starts. Your program needs to check again to notice the change. The place you put each instruction matters.

Set up once, then keep watching

Use "on start" for setup. It can set a count to zero, display a welcome picture, or close a model gate. It runs when the board starts or resets.

Use "forever" to keep reading inputs and setting outputs. A typical round reads a sensor, makes a decision, and changes an output. Event blocks can also respond whenever their event happens.

A plant alarm might repeat these steps:

1. Read the moisture sensor.
2. If the soil is dry, show a sad face and beep.
3. Else, show a happy face.
4. Pause for 1,000 ms.

It checks about once each second. The reading belongs inside the loop too. Reading once at startup and comparing that old number forever would miss new conditions.

Repeat a set number of times

A "repeat" loop finishes after its chosen number of rounds. To flash a warning three times, repeat: LED on, pause 200 ms, LED off, pause 200 ms.

Each round waits 400 ms. Three rounds wait 1,200 ms, or 1.2 seconds. After the third round, the program moves to the block below the loop. A forever loop would keep flashing.

Waiting affects checking

A pause holds up the instructions in that loop. During a ten-second pause, that loop does not check its sensor or button again. A short press can happen and finish between checks. Other event blocks can still run in editors that handle events separately.

A "repeat until" loop checks its condition between rounds. It leaves the loop when a check finds the condition true. If it checks whether A is held, A must be held at the time of a check.

Give an output one clear rule

Two forever loops can fight over the same light. One turns it on; the other turns it off. The light can flicker as their instructions take turns. Put the choices in one place, with a condition that selects the intended state.

A sensor gives a number. A condition turns a comparison into true or false. Your program uses that answer to choose an action.

Read the comparison aloud

The threshold is the number where the behavior changes. Use real sensor readings to choose it.

Make a night light respond both ways

Use this decision inside forever:

if light level < 50:
  turn LEDs on
else:
  turn LEDs off

At 15, the condition is true, so the LEDs turn on. At 140, it is false, so they turn off. This choice is called selection.

Now follow a change: first the room is dark, then bright. The first check turns the LEDs on. The next bright check reaches else and switches them off. If you leave out else, no instruction turns them off. The earlier on state remains.

Test the exact threshold

At a reading of 50, "less than 50" is false. The LEDs turn off. To include 50 in the on case, use "less than or equal to 50". Decide which behavior you need before choosing the sign.

A useful set of tests is 49, 50, and 51. These readings check just below, exactly at, and just above the boundary. A very dark and a very bright test alone can miss an incorrect equals sign.

Check the direction

A too-hot warning can use "temperature > 30". At 31 °C it shows "HOT" and plays a tone. At exactly 30 °C it shows "OK". Greater than does not include equality.

For a night light, "light > 50" would reverse the job. It would shine in the bright case. Say the whole rule aloud: "If the light reading is less than 50, turn on." This helps you connect the sign to the action.

Buttons can supply conditions too. "If A is pressed, motor on; else, motor off" chooses a state on every check, using the button's two states.

Some devices need three choices or two clues at once. You can join conditions and order decisions so the output matches each situation.

Follow an else-if chain

An else-if chain checks from the top. The first true branch runs. The later branches are skipped.

if temperature < 18:
  show "COLD"
else if temperature > 25:
  show "HOT"
else:
  show "OK"

A reading of 17 reaches "COLD". At 18, the first check is false. The second check is false too, so it shows "OK". A reading of 25 also shows "OK"; 26 shows "HOT". The middle range includes both 18 and 25.

Put a stricter check first

Consider "if temperature > 10, show WARM; else if temperature > 25, show HOT". At 30, the first check is already true. The program shows "WARM" and skips "HOT".

Check "greater than 25" first, then "greater than 10". A high reading can now reach "HOT". Separate if blocks behave differently: both can run and change the same display. Use one chain when only one choice should happen.

Join clues with and or or

And needs both conditions to be true. A garden light might require darkness and someone nearby. Use "light < 50 and distance < 100 cm".

Or needs at least one condition to be true. A model alarm can beep if a door opens or a window opens. It beeps when either opens, and also when both open.

Check a range

To ask whether temperature is from 18 to 25, use "temperature ≥ 18 and temperature ≤ 25". A reading of 20 passes both checks. At 27, the upper check fails.

Using or here would accept every reading: even 40 is at least 18. Test both ends and a value outside each end. For the three-message thermometer, test 17, 18, 25, and 26 to reach all branches and check both boundaries.

A smart device starts with someone's need. Before you choose blocks or parts, decide who will use it and what problem it should solve.

Write things you can check

Design criteria say what a successful device must do. "Make a good light" is hard to test. "The light turns on within two seconds of darkness" gives you a clear check. Ask where the device will sit and how people will control it.

Start with a simple version. Add extra features after its main job works. A device with many unfinished features may never solve the original problem.

Plan a plant reminder

The class plant keeps drying out. You want a reminder that tells someone to water it.

First explore the sensor in wet and dry soil. Use those readings to choose the threshold. A number that works for one moisture sensor may mean something different on another.

The silence button needs a remembered setting. Once pressed, the program keeps the beep silent while the soil stays dry. When watering is detected, it clears that setting for next time. Otherwise, a single press could silence every future warning.

Draw or write the algorithm

An algorithm is the steps your program follows. Write numbered steps or draw a flowchart. In a flowchart, an oval marks the start. A rectangle shows an action. A diamond asks a yes-or-no question. Labeled arrows show which path to follow, and an arrow back shows repetition.

For a model gate, the plan might be: check for an animal nearby; open the gate; wait ten seconds; close; return to the check. A servo supplies the two positions. Try the plan with a toy animal before building the model.

Think about difficult moments

What happens if both buttons are pressed? What if a reading equals the threshold? Can the user stop the device? Add tests for these cases to your plan. A greenhouse logger, a door alarm, and a buggy that stops near walls all need different inputs and different checks.

The simulator can help you try your blocks. The real device also needs matching connections, power, and the newest copy of your program.

Connect with care

Switch off or unplug power before changing connections. Keep electronics dry and use the battery pack supplied with your kit. Tell an adult if anything gets hot, smells strange, or has a damaged battery.

Follow your kit's connection pictures. Match the labeled pins or sockets to the program. Some boards use numbers such as 0, 1, and 2; others use letters. Power and ground have their own labels. Ground is often marked "GND" or "−".

Some parts, including many LEDs, work only one way around. Match the kit's + and − markings. Fasten clips firmly and keep their metal ends apart. Touching clips can connect places that should stay separate.

Match the pin in the program

An LED is connected to pin 1. The program says "turn pin 0 on". The program can run without reporting an error, but the LED stays dark.

1. Find the LED's connection in the kit plan.
2. Read its pin label: 1.
3. Change the output block to pin 1.
4. Send the changed program to the board.

The hardware connection and software instruction now point to the same place.

Download and try it

To download a program means to send it to the board. Many boards use a USB cable; some also support Bluetooth. A saved change in your editor does not update the board until you send it again.

Try a tiny program first, such as showing a heart. Check that the real board runs it. Then send your device program. Most classroom boards keep their program after unplugging and run it again when powered.

Build around the parts

Keep a light sensor uncovered. Place moisture-sensor prongs in the soil. Fix a motor firmly and leave enough wire for moving parts. A sensor hidden by your model's roof cannot measure the light you intended.

A simulator is an on-screen model. It helps check program logic, but its readings and movement can differ from the real device. A heavier gate may move slowly. A bright window may change the sensor readings. Test the model where people will use it.

A device working once is a useful start. Testing checks whether it does its job in different situations, including the awkward ones.

Compare expected and actual results

The expected result is what should happen. The actual result is what did happen. Write both so you can explain a pass or failure.

For a night light using "light < 50", a test table might look like this:

Add an actual-result column when you run the tests. The last test checks a change over time. It can reveal a missing else that two separate startup tests miss.

Test every input and every branch. Include values at boundaries and actions such as holding a button or pressing both buttons. Use the real location as well as the simulator.

Find one cause at a time

A fault, or bug, makes the actual result differ from the expected one. It can be hardware or software.

• Hardware: loose clip, wrong pin, low battery, backward part, covered sensor.
• Software: wrong comparison, missing else, old program, poor threshold, check outside a loop.

Use a clear search order:

1. Describe exactly what fails and when.
2. Check power and whether the latest program was sent.
3. Match each connection to the plan.
4. Test one part with a tiny program.
5. Display sensor readings and check the decision rule.
6. Change one thing, then repeat the failed test.

Use readings to explain a failure

A night light never turns on. Its covered reading is 70, and uncovered is 160. The program uses "light < 50". Both readings fail that condition.

Try a threshold of 110. Now 70 passes and 160 fails. Test both situations again. Changing the threshold explains this fault; replacing several parts at once would hide which change helped.

Judge the finished device

To evaluate, compare the device with each design criterion. Ask its users to try it. A bright warning might work well for one person but be hidden from another's seat. Use their feedback and your results to choose the next improvement.