Tinkercad Maker Course

The course has eight main parts, plus a workbook, a connectors part and a build checker. Do Part 1 first, because everything else uses it. After that you can jump around.

Each lesson ends with a tick box. Your ticks stay in this browser, and the bar at the top shows how far you are.

The coloured boxes

Electricity uses four letters again and again. Each one always has the same colour on this page, so you can spot it fast.

Every formula is shown the same way: first what each letter means, then the idea in plain words, then the equation.

Electricity is tiny particles called electrons moving through a material, all in the same direction.

Everything is made of atoms. Atoms have electrons around them. In metals like copper, some electrons are loose. They can hop from atom to atom. That is why wires are made of copper.

On their own, loose electrons just drift around at random. To get them to move one way, something has to push them. A battery does that.

The water picture

Think of a circuit like water in pipes. It is not perfect, but it works for almost everything in this course.

These three words are the whole of basic electricity. Learn what each one feels like.

Big and small numbers

Electronics uses very small currents and very big resistances, so we put a short word in front of the unit. These are the four you need.

Current only flows when there is a full loop, from + all the way back to −.

• Closed circuit: a complete loop. Current flows. Things work.
• Open circuit: there is a gap somewhere. A switch is just a tidy way to make a gap on purpose.
• Short circuit: a path with almost no resistance from + to −. Current takes the easy path, skips your parts, and gets huge. Wires and batteries heat up fast.

Which way does current go?

We draw current flowing from + to −. This is called conventional current. The electrons actually move the other way, from − to +. People decided the direction before electrons were discovered, and the old rule stuck. Every diagram, datasheet and Tinkercad part uses + to −, so you can too.

One rule links push, flow and squeeze. You will use it more than anything else in electronics.

A worked example, one step at a time

1. A 9 V battery is connected to a 450 Ω resistor. What current flows?
2. We want I, so use I = V ÷ R.
3. Put the numbers in: I = 9 ÷ 450.
4. Work it out: I = 0.02 A.
5. Turn it into mA (× 1,000): 20 mA.

Power tells you how much energy a part uses every second. Most of it turns into heat, light or movement.

Why this matters to you

• Normal small resistors can handle ¼ W (0.25 W). More than that and they get hot and can burn.
• Example: 5 V across a 220 Ω resistor. I = 5 ÷ 220 = 0.023 A. P = 5 × 0.023 = 0.11 W. That is fine.
• Example: 9 V across a 10 Ω resistor. I = 0.9 A. P = 8.1 W. Far too much. It would smoke.
• Motors need much more current than an Arduino pin can give, which is why they use a separate driver (see C9).

There are only two ways to join parts: one after another, or side by side.

Lights in a house are wired in parallel. That is why one bulb can blow and the rest stay on. Old Christmas lights were in series, so one dead bulb made the whole string go dark.

Batteries follow the same idea. Two 1.5 V batteries in series (+ to −) give 3 V. In parallel they stay at 1.5 V but last longer.

These are the parts used in almost every beginner project. The drawing is the circuit symbol, the way the part is drawn on a plan.

Resistors are too small to print numbers on, so they use coloured bands. The common type has four bands.

1. Band 1: first digit.
2. Band 2: second digit.
3. Band 3: how many zeros to add (the multiplier).
4. Band 4: how accurate it is, usually gold (±5%). Gold goes on the right when you read it.

The colours in order, 0 to 9: black, brown, red, orange, yellow, green, blue, violet, grey, white. A kid-safe way to remember: Big Brown Rabbits Often Yawn Gently By Violet Gardens Weekly.

Picking the resistor for an LED

An LED does not limit its own current. Without a resistor it would take far too much and burn out. The resistor's job is to soak up the extra voltage.

Resistors only come in set sizes. If your answer isn't a real size, round up to the next one. A bigger resistor means a bit less current, which is always the safe side.

Nothing in Tinkercad can hurt you. When you or your learners move to real parts, these rules matter.

• Never touch mains electricity (the wall socket, 230 V in Spain and the UK). Everything in this course runs on 12 V or less.
• Unplug before rewiring. Disconnect USB or the battery, change the wires, check, then power up.
• Check for shorts first. Trace + to − with your finger before connecting power. If anything gets warm, unplug at once.
• Lithium batteries (phone or drone style) can catch fire if punctured, bent or shorted. Use AA packs or USB power for beginners.
• Polarity parts: LEDs, electrolytic capacitors, buzzers and some sensors only work one way round. A backwards capacitor can pop.
• Hot tools: a soldering iron tip is around 350 °C, and a 3D printer nozzle around 200 °C. Use a stand, work in an airy room, and wash hands after handling solder.

Every electricity question is solved with the same seven steps. Learn them once and every exercise gets easier.

1. Read it and draw it. Sketch the circuit, even roughly. Pictures stop mix-ups.
2. Write what you know, one per line, with units: V = 9 V.
3. Write what you want, with a question mark: I = ?
4. Change to plain units: kΩ to Ω, mA to A. Formulas only work in V, A, Ω and W.
5. Pick the formula. Write it with letters first, before any numbers.
6. Put the numbers in and work it out on a calculator.
7. Check it. Is the unit right? Is the size sensible? An LED current of 500 A is wrong.

A worked example

A 12 V supply is connected to a 2.4 kΩ resistor. What current flows?

Most mistakes in electronics are unit mistakes, not maths mistakes. Each step on this ladder is × 1,000.

• Going right (to a smaller unit): multiply. You need more of the small ones, so the number gets bigger.
• Going left (to a bigger unit): divide. The number gets smaller.
• The safe trick: always go to the plain unit first, then to the one you want.

Exercises

The three versions of the same rule. Cover the letter you want in the triangle (E4) and the rest shows the sum.

Exercises

The main rule is P = V × I. When a question doesn't give you both V and I, use Ohm's law to find the missing one first. That also gives two shortcuts:

Choosing a resistor's power rating: pick one rated at least double the power it will turn into heat. Resistors near their limit get very hot. Common ratings: ¼ W, ½ W, 1 W, 2 W, 5 W.

Exercises

The rule from E8: R = (Vs − Vf) ÷ I. With several LEDs in series, add up all their Vf first.

Resistors are sold in standard sizes. The common set is called E12, and it repeats in every ×10 band:

So the real sizes go 100, 120, 150, 180, 220, 270, 330, 390, 470, 560, 680, 820, then 1 k, 1.2 k, and so on. If your answer falls between two sizes, round up.

Exercises

Exercises

Exercises

The trick: squash the parallel part into one resistor first. Then it's just a series problem.

1. Find the parallel pair's combined value: (R2 × R3) ÷ (R2 + R3).
2. Add the series resistor to it. That's the total.
3. Total current = V ÷ total R.
4. Voltage across the series resistor = I × R1. The pair gets what's left.

Exercises

From C8: Vout = Vin × R2 ÷ (R1 + R2), where R1 is on top and R2 is below, going to GND.

To design one (find R1 for the Vout you want), turn it round:

Exercises

Two simple rules, named after the scientist Gustav Kirchhoff, explain every circuit. You've already been using them.

Exercises

One cell is one chemical unit, like a single AA. A battery is strictly several cells joined, like a 9 V block, which has six small cells inside. Everyday speech calls both "batteries".

mAh (milliamp-hours) says how much charge a battery holds. 2,000 mAh means it could give 2,000 mA for one hour, or 100 mA for 20 hours, or 1 mA for 2,000 hours. Real batteries give less than the label, so the course uses 70% of the label value.

Real values depend on the brand and on how much current you draw. Check the label or the datasheet.

Exercises

Power is how fast energy is used. Energy is the total, so it depends on time as well.

The exercises use 0.20 € per kWh as an example price. Real prices change; check a bill for the real number.

Exercises

The sums you need when writing Arduino code. All of them come from Part 4.

Exercises

A multimeter reading tells a story, if you know three clues:

• Full supply voltage across one part, and 0 V across the others: that part is where the loop is broken. No current flows, so nothing else drops any voltage.
• 0 V across a part that should be working: no current is flowing through it, or it's been shorted out by a wire.
• Something getting hot and a huge current: a short circuit. Disconnect the power first, then look.

Exercises

New numbers every time, with the same step-by-step answers. Good for revision, or for giving each learner their own problem.

A wire has two parts: a copper core that carries the current, and plastic insulation that stops it touching anything else.

Wire thickness

Thickness is often given in AWG (American Wire Gauge). It works backwards: a bigger number means a thinner wire. Thicker wire can carry more current without getting hot.

Wire colours

Stripping means taking the plastic off the end so the copper can connect. You need wire strippers (pliers with sized notches) and flush cutters (small snips).

1. Cut the wire to length with flush cutters, plus a little extra.
2. Find the right notch. Strippers have holes marked in AWG or mm. Match your wire. Too small a notch cuts the copper too.
3. Put the wire in the notch so the length you want to strip sticks out past the jaws. About 6 mm for a breadboard, 5–7 mm for a screw terminal.
4. Squeeze firmly and pull the end of the plastic off in one smooth move.
5. Check the copper: shiny, no nicks, no strands cut off. If strands are missing, cut it off and start again.
6. Stranded wire only: twist the strands tightly between finger and thumb so none stick out.
7. Optional, stranded: "tin" it by melting a little solder into the twist (J11). It then behaves like solid wire.

Almost every connector comes in two halves that fit together. Electronics uses two old-fashioned words for them:

• Pin header (male): a strip of pins. Sensor modules often come with one to solder on yourself.
• Socket header (female): a strip of holes. The black strips along the edges of an Arduino Uno are female headers.
• Breadboard holes act like female sockets: they take male pins and part legs.

Pitch: the spacing between pins

Pitch is the distance from the middle of one pin to the middle of the next. Almost all hobby electronics uses 2.54 mm (0.1 inch), exactly the same as breadboard holes. Some small parts use 2.0 mm, 1.25 mm or 1.0 mm. Those won't fit a breadboard, so check the pitch before you buy.

Breaking headers to length, step by step

1. Count the pins you need on the module.
2. Grip the header with pliers right after the last pin you want.
3. Bend it sideways until it snaps cleanly at the notch between pins.
4. Female headers don't snap cleanly: cut through one extra socket with flush cutters, then sand the end flat.

Jumper wires (often called Dupont wires) are short wires with a ready-made end on each side. They come in three kinds, named after their two ends.

Wiring an Arduino to a breadboard, step by step

1. Plan the colours before you start: red for 5V, black for GND, a different colour for each signal.
2. Unplug the USB while wiring.
3. Push one end of a red M-M jumper fully into the Uno's 5V socket. Push the other end into the breadboard's + rail.
4. Same with a black jumper from GND to the − rail.
5. Add the signal wires, one at a time, checking each pin number against your plan or your code.
6. Tug gently on each one. A good connection doesn't slide out.
7. Keep wires short and low. Long loops catch on fingers and pull out.

C2 showed which holes are joined. This lesson is about making connections that are reliable and easy to check.

1. Wire the power rails first: 5V to the red-striped + rail, GND to the blue-striped − rail. On long breadboards the rails can be split halfway: add a short wire across the gap.
2. Straighten legs with pliers before pushing them in. Bent legs miss the hole's metal clip.
3. Push straight down until the part sits close to the board.
4. LEDs: the long leg is +. If you trim the legs, keep the + one a little longer, or bend it, so you can still tell.
5. Resistors: bend both legs down at 90° close to the body. Span 3 or 4 holes so they lie flat.
6. Chips: always straddle the middle gap, so each pin gets its own column. The notch or dot marks pin 1.
7. Buttons: also straddle the gap. Then the two pins on the same side are the ones that get joined when pressed.
8. Check by colour: trace every red wire, then every black one, before plugging in.

USB plugs

Every USB plug gives 5 V. The shapes differ:

Barrel jack

A round plug used by power adapters. The Arduino Uno's is 5.5 mm across the outside with a 2.1 mm pin, and it is centre positive: the pin in the middle is +.

Reading the symbol, step by step: find this small drawing on the adapter's label. Follow the line from the dot in the middle. If it leads to +, the adapter is centre positive and safe for an Uno. If it leads to −, don't use it.

Battery leads and holders

• 9 V snap: clips onto a 9 V block. Red wire +, black wire −.
• AA holders: hold 2, 4 or 6 cells in series. Many have an on/off switch and come with bare wire ends or a barrel plug.
• Coin cell holder: for a CR2032. Fine for an LED or a tiny sensor, too weak for an Arduino.

Powering an Arduino Uno, step by step

These hold bare wire ends firmly. You'll find screw terminals on motor driver boards, power supplies and LED strip controllers.

Screw terminal, step by step

1. Strip 5–7 mm off the wire (J2). Twist stranded wire tight.
2. Open the terminal: turn the screw anticlockwise a few turns with a small flat screwdriver.
3. Push the wire in the front opening until the plastic insulation just touches the terminal. No bare copper should show outside.
4. Tighten the screw clockwise, firmly but not hard enough to crush the wire.
5. Tug test: pull the wire gently. It should not move at all.
6. Check no stray strand reaches the next terminal.

Lever connector, step by step

1. Strip the wire to the length printed on the side of the connector.
2. Lift the orange lever all the way up.
3. Push the wire in until it stops.
4. Press the lever down. It clicks.
5. Tug test. To undo, lift the lever and pull.

Lever connectors join two to five wires together with no tools, and take solid and stranded wire. Handy for joining battery packs and motor leads.

JST is a family of small plastic plugs. They are keyed, meaning their shape only lets them fit one way round, and most of them latch so they can't fall out.

Plugging in a small LiPo battery, step by step

1. Find the + and − marks on the board, next to its battery socket.
2. Line the plug up without pushing: is the red wire on the + side?
3. If you're not sure, measure the plug with the multimeter on DC volts (J9): red probe on the pin you think is +. A positive reading means you're right.
4. Push straight in until it clicks.
5. To unplug, pull on the plastic housing, never on the wires. A fingernail or small pliers on the housing help.

Crocodile clips

Spring clips with teeth, on short wires. Great for quick tests and for the micro:bit, whose edge has five big rings marked 0, 1, 2, 3V and GND.

Lighting an LED from a micro:bit, step by step:

1. Clip one lead onto ring 0. Clip its other end onto a 100 Ω resistor's leg.
2. Clip a second lead from the resistor's other leg to the LED's long leg.
3. Clip a third lead from the LED's short leg to the GND ring.
4. Check no two clips touch each other or two rings at once.
5. Code: set pin 0 to on (digital write 1).

The multimeter's leads

A multimeter has two leads with banana plugs, and usually three or four sockets. Getting the leads in the right sockets is the most important step. Pick a job below to see exactly how to set it up.

Sensor and display modules print short labels next to their pins. Once you know these, you can wire up almost anything.

Connecting any module, step by step

1. Read every pin label. They may be on the back. If there are none, find the module's page in the shop or its datasheet.
2. Check its voltage. Some newer modules are 3.3 V only, and 5 V can damage them. If it says 3.3 V, power it from the 3.3V pin.
3. Write a pin table before you touch a wire: module pin, Arduino pin, wire colour.
4. Unplug the Arduino.
5. Power first: VCC with a red jumper, GND with a black one.
6. Then the signals, one at a time, ticking them off your table.
7. Check for a short: with the beep test, VCC to GND must not beep.
8. Power up and test with the simplest example code first, printing readings to the Serial Monitor.

Soldering joins metal parts with a melted metal called solder. It makes a permanent connection that can't wiggle loose.

You need

• A soldering iron with a stand, ideally with temperature control.
• Lead-free solder wire with flux inside (often marked "rosin core").
• A damp sponge or brass wool to clean the tip.
• Safety glasses, flush cutters, and a fan or an open window.

A through-hole joint (a part's leg in a board)

1. Heat up the iron to about 330–350 °C.
2. Tin the tip: melt a little solder onto it, then wipe it on the sponge. A shiny tip passes heat well.
3. Place the part and bend its legs out slightly underneath so it doesn't fall out.
4. Heat the joint: touch the tip so it touches the copper pad and the leg together, for 1–2 seconds.
5. Feed the solder into the joint on the opposite side from the tip, not onto the iron. It should flow around the leg.
6. Remove the solder first, then the iron, about a second later.
7. Don't move it for 2–3 seconds while it sets.
8. Check the shape (below), then trim the leg with flush cutters, pointing it away from your face.

• Cold joint (a ball): the pad wasn't hot enough. Reheat it with the tip touching both pad and leg, and add a touch more solder.
• Bridge: drag the hot tip between the pads, or use desoldering braid (copper mesh that soaks up solder) to remove the extra.

Soldering a header onto a module

1. Push the header's long pins into a breadboard. The breadboard holds them perfectly straight.
2. Sit the module on top, short pins through its holes.
3. Solder one pin at one end. Check the module is flat. If not, reheat that pin and straighten it.
4. Solder the pin at the other end, then all the rest.

Joining two wires, with heat shrink

1. Slide a piece of heat-shrink tube onto one wire first, well away from the joint. (Everyone forgets this once.)
2. Strip 6 mm off both wires and twist each one.
3. Tin both ends: heat each one and let a little solder soak in.
4. Hold them side by side, touching, and heat them until the solder melts them together.
5. Let it cool, slide the heat shrink over the joint, and shrink it with a heat gun or the side of the iron (not a flame).

1. Go to tinkercad.com and sign up. Choose Teacher if you plan to run classes. That choice is permanent, and it unlocks Classes.
2. The dashboard on the left lists your 3D Designs, Circuits, Codeblocks, Classes and Collections (folders).
3. Press Create to start something new and pick the workspace.
4. Your work saves itself every few seconds. There is no save button.
5. New designs get silly random names. Click the name at the top left of the editor to rename it. Do this first, every time.

Sharing and copying

• Share (top right in an editor) gives you an invite link or lets you make a design public.
• On any public design, Tinker this makes your own copy to change. The original stays safe.
• To give a class a starting point, make one "starter" design, then share it so everyone copies it.

Moving the camera

Click a shape to select it. Little handles appear. Each one does one job.

Typing exact sizes

While dragging a handle, numbers appear. Click a number and type the size you want, then press Enter. This is how you make parts that fit.

Handy moves

• Shift while stretching from a corner keeps the shape's proportions.
• Alt while stretching grows it from the centre.
• Arrow keys nudge one grid step. Ctrl + ↑ / ↓ moves up and down.
• D drops a floating shape back onto the workplane.
• Alt + drag makes a copy as you move it.

The main trick in Tinkercad: a Hole shape cuts away whatever it overlaps, but only after you group them.

1. Place a solid box.
2. Place a cylinder so it pokes through the box.
3. Select the cylinder, then click Hole in the shape box (or press H). It turns see-through and striped.
4. Select both: drag a rectangle around them, or Shift + click each.
5. Press Group (Ctrl + G). The hole is cut out.

Groups can be undone at any time with Ungroup (Ctrl + Shift + G). Nothing is lost. This makes Tinkercad very forgiving.

Other ways to combine

• Colour after grouping: a group takes one colour. Turn on Multicolor in the shape box to keep each part's own colour.
• Intersect (Ctrl + I) keeps only the part where shapes overlap. Good for odd curved shapes.
• Lock (Ctrl + L) stops a finished part being moved by accident. Hide (Ctrl + H) gets it out of the way.

Sketch: draw your own outline

1. Drag the Sketch tool from the Basic Shapes panel onto the workplane. A drawing window opens.
2. Draw straight lines (key 1) or curves (key 2, press and drag to bend).
3. Join back to the start. A closed shape fills in, which means it's ready.
4. Press Finish Sketch. It becomes a 3D shape you can resize like any other.
5. Double-click it later to edit the drawing.

There is also a revolve sketch. Draw half an outline and it spins it round a line, like a pottery wheel. Use it for vases, chess pieces and knobs.

Text

Drag Text from Basic Shapes. Type in the shape box and pick a font. Bold, simple fonts print best.

Shape Generators

Pick Shape Generators in the shapes panel to find ready-made shapes with settings: gears, springs, threads, stars and more. Change the numbers, then group with your design.

Import

The Import button brings in SVG drawings (a logo becomes a flat shape you can thicken), and STL or OBJ 3D models.

A 3D printer (the common kind, called FDM) squeezes hot plastic out of a nozzle, one thin layer at a time, from the bottom up. Most print rules come from that.

Getting the file out

• Press Export. Choose .STL or .OBJ for 3D printing, .GLB for 3D viewers and game engines, or .SVG for laser cutting.
• SVG export takes the outline of the shapes touching the workplane. Design flat, then export.
• Open the STL in a slicer (the printer's program, like Cura, PrusaSlicer or Bambu Studio). It turns the shape into printer instructions.

Four builds, easiest first. Each uses the skills above. Open one to see the steps.

Working with wires

• Click a leg or a hole, then click where the wire should end. That's a wire.
• Click on empty space mid-wire to add a bend. Double-click a finished wire to add a bend point you can drag.
• Select a wire to change its colour. Use red for + and black for −/GND, always. Pick other colours for signals.
• Select a part and press R to rotate it.
• Hover over a part's leg to see its name, like "anode" or "GND".

A breadboard lets you join parts without soldering. Under the holes are metal strips. Holes on the same strip are joined.

• Middle area: each column of 5 holes (a–e) is joined. The f–j half is a separate set. The gap in the middle splits them.
• Power rails: the long rows along the edges, marked + and −. Each one is joined along its whole length.

Battery, resistor, LED, in one loop. This is the same circuit as the live one at the top of the page.

1. Create a new Circuit. Drag in a Breadboard Small, a 9V Battery, a Resistor and a red LED.
2. Set the resistor to 470 Ω. (9 − 2) ÷ 470 ≈ 15 mA. Check it with Tool 4.
3. Put the LED across two columns. Its bent leg is +.
4. Put the resistor from the LED's straight leg column to another column.
5. Battery + (red) to the LED's bent-leg column. Battery − (black) to the resistor's free column.
6. Start Simulation. The LED lights.

The multimeter is your eyes inside a circuit. Search the components panel for Multimeter. Click it to choose what it measures.

• A negative number just means the probes are the wrong way round. Swap them.
• A reading of 0 often means the wrong mode is selected.

An Arduino is a small computer on a board. It runs one program in a loop, forever. It can switch things on and off, and read sensors.

Setting up the breadboard rails

Wire Arduino 5V to the breadboard + rail (red wire) and GND to the − rail (black wire). Now every part can get power from the rails. Do this at the start of every Arduino build.

Press Code with an Arduino in your circuit. The drop-down at the top has three modes:

• Blocks: drag blocks like Scratch. Best for beginners.
• Blocks + Text: blocks on one side, the real Arduino code (C++) on the other. Great for learning to read code.
• Text: type real Arduino code. Switching from Blocks to Text is one way: your blocks get replaced by text.

Every Arduino program has two parts

void setup() {
  // runs ONCE when the power comes on
  // tell each pin its job here
}

void loop() {
  // runs again and again, forever
  // the main work goes here
}

The Serial Monitor

At the bottom of the code panel is Serial Monitor. It shows text your program prints. Use it to see what's going on inside.

Serial.begin(9600);      // in setup(): switch the monitor on
Serial.println(42);       // in loop(): print a value on a new line

The code panel also has a debugger (the bug icon). Click a line number to set a breakpoint, and the simulation pauses there so you can check values.

Output: blink an LED

Wire: pin 13 → 220 Ω resistor → LED bent leg. LED straight leg → GND.

void setup() {
  pinMode(13, OUTPUT);      // pin 13 sends power out
}

void loop() {
  digitalWrite(13, HIGH);   // LED on (5 V)
  delay(1000);              // wait 1 second
  digitalWrite(13, LOW);    // LED off (0 V)
  delay(1000);
}

Input: read a button

A pin that isn't connected to anything "floats". It picks up noise and reads random HIGHs and LOWs. INPUT_PULLUP fixes this. It connects the pin to 5 V through a resistor inside the chip, so it reads HIGH when nothing happens.

Wire the button between pin 2 and GND. Pressing it pulls the pin down to 0 V, so pressed reads LOW. This feels backwards at first.

const int BUTTON = 2;
const int LED = 13;

void setup() {
  pinMode(BUTTON, INPUT_PULLUP);  // button wired between pin 2 and GND
  pinMode(LED, OUTPUT);
}

void loop() {
  if (digitalRead(BUTTON) == LOW) {  // LOW means pressed
    digitalWrite(LED, HIGH);
  } else {
    digitalWrite(LED, LOW);
  }
}

Analog in: reading a voltage

The Arduino cuts 5 V into 1024 small steps. analogRead() tells you which step the pin is on: 0 at 0 V, 1023 at 5 V.

The voltage divider

Two resistors in series split the voltage. The middle point gets a share. This is how a potentiometer works, and how you read an LDR.

PWM out: fake "half on"

Digital pins can only be fully on or fully off. PWM (pulse width modulation) flicks the pin on and off about 500 times a second. On for a quarter of the time looks like a quarter brightness. analogWrite(pin, 0–255) sets how much of the time it's on. Only ~ pins can do it.

// Dimmer: potentiometer middle leg to A0, outer legs to 5V and GND.
// LED + 220 Ω on pin 9.
void setup() {
  pinMode(9, OUTPUT);
  Serial.begin(9600);
}

void loop() {
  int knob = analogRead(A0);        // 0 to 1023
  int brightness = knob / 4;        // squash to 0 to 255
  analogWrite(9, brightness);
  Serial.println(knob);
  delay(20);
}

Buzzer

Piezo + leg to pin 8, − leg to GND. tone(8, 440, 200); plays the note A for 200 ms. 262 is middle C.

Servo

Three wires: brown or black to GND, red to 5V, orange or yellow (signal) to a ~ pin.

#include <Servo.h>
Servo arm;

void setup() {
  arm.attach(9);                        // signal wire on pin 9
}

void loop() {
  int knob = analogRead(A0);
  int angle = map(knob, 0, 1023, 0, 180); // knob position to angle
  arm.write(angle);
  delay(15);
}

DC motor

A motor needs far more than 20 mA, so never wire it straight to a pin. Use an NPN transistor or a motor driver (search "L293D" in Tinkercad) between the pin and the motor, and put a diode across the motor to catch the voltage spike when it stops.

Sensors in Tinkercad

Tinkercad Circuits also has the BBC micro:bit. Search for it in the components panel. It's often used in UK schools in Years 7 to 9.

• It has a 5 × 5 LED screen, two buttons and a few sensors built in, so you can do a lot with no wiring.
• Its code blocks look like Microsoft MakeCode, which learners may know from school.
• It runs on 3.3 V, not 5 V. Redo your LED resistor sums with Tool 4.
• Use it as a friendly first step, then move to Arduino for bigger builds.

Eight builds in order. Each one adds one new idea. For every Arduino build, first wire 5V and GND to the breadboard rails (C5).

void setup() { pinMode(2, INPUT_PULLUP); }

void loop() {
  if (digitalRead(2) == LOW) {   // pressed
    tone(8, 659, 300); delay(300); // ding (E)
    tone(8, 523, 500); delay(600); // dong (C)
  }
}

const int DARK = 300;   // change after watching the Serial Monitor

void setup() { pinMode(9, OUTPUT); Serial.begin(9600); }

void loop() {
  int light = analogRead(A0);
  Serial.println(light);
  if (light < DARK) {
    digitalWrite(9, HIGH);   // it's dark: light on
  } else {
    digitalWrite(9, LOW);
  }
  delay(100);
}

void setup() {
  pinMode(9, OUTPUT);
  pinMode(2, INPUT_PULLUP);
  Serial.begin(9600);
  randomSeed(analogRead(A5));      // a different game every time
}

void loop() {
  Serial.println("Get ready...");
  delay(random(2000, 5000));       // wait 2 to 5 seconds
  digitalWrite(9, HIGH);
  unsigned long start = millis();  // time in ms since power on
  while (digitalRead(2) == HIGH) { } // wait for the press
  unsigned long took = millis() - start;
  digitalWrite(9, LOW);
  Serial.print("Your time: ");
  Serial.print(took);
  Serial.println(" ms");
  delay(2000);
}

const int TRIG = 7, ECHO = 6, BUZZ = 8;

void setup() {
  pinMode(TRIG, OUTPUT);
  pinMode(ECHO, INPUT);
  Serial.begin(9600);
}

void loop() {
  digitalWrite(TRIG, LOW);  delayMicroseconds(2);
  digitalWrite(TRIG, HIGH); delayMicroseconds(10);  // send the click
  digitalWrite(TRIG, LOW);
  long time = pulseIn(ECHO, HIGH);                // echo time in µs
  float cm = time * 0.0343 / 2;
  Serial.println(cm);

  if (cm < 100) {
    tone(BUZZ, 880, 50);
    delay(cm * 5);   // closer = shorter gap = faster beeps
  }
  delay(60);
}

1. Open your Tinkercad circuit next to this page. This board has the same layout as Tinkercad's Breadboard Small: 30 columns, rows a to j, and a + and − rail along the top and bottom.
2. Type the pins your code uses in the box under the board, like 13 or 2, 9, A0.
3. Copy each part: pick it in the toolbar, then tap the same holes it uses in Tinkercad. For wires, tap where each end goes, including the Arduino's pins.
4. Read the results. Tap a problem to see the red marks on the board. Fix it here and in Tinkercad, until it says Ready to run.
5. Investigate: in Inspect mode, tap any hole to light up everything electrically joined to it. If two things you expect to be joined don't light up together, that's your broken connection.

The board opens with an example that has mistakes in it. Your own build is saved in this browser. On a phone, turn it sideways and scroll the board left and right.

In Codeblocks, blocks don't move a sprite. They build a 3D shape. Press Run and you watch it being made, step by step.

• Create blocks add shapes: box, cylinder, sphere, text.
• Modify blocks move, rotate, scale and colour them, and turn them into holes.
• Control blocks repeat. Math and Data blocks add numbers and variables.
• The finished shape can be exported for printing, or sent into a 3D design.

Sim Lab adds physics to your 3D designs. Switch to it from a 3D design. If you can't find it, check tinkercad.com/simlab.

• Shapes fall with gravity, bounce and roll.
• Give each shape a material, like wood, rubber or plastic. It changes weight and bounce.
• Set shapes as static (stays put, like the floor) or dynamic (moves).
• Throw shapes at each other, build simple machines, and share the result.

Hands off their mouse. Use the smallest help that gets them moving again.

• Wait at least five seconds after a question. Thinking takes time.
• Praise the method, not the result: "you checked the multimeter first, that's exactly what engineers do".
• Three people stuck on the same thing? Stop the room and explain it once to everyone.

When a circuit doesn't work, check things in this order. It finds most faults in under two minutes. Use it yourself, or go through it with a learner.

1. One sentence. "A box that beeps when someone opens it." If you can't say it in one sentence, it's two projects.
2. Paper sketch. Draw the object and list the inputs (what it senses) and outputs (what it does).
3. Simulate the circuit in Tinkercad Circuits. Get the smallest version working first, then add one thing at a time.
4. Design the body in 3D Design. Measure real parts with a ruler, not from memory.
5. Build it real on a breadboard, then test.
6. Fix and repeat. Change one thing per go so you know what helped.
7. Share it. A photo, the Tinkercad link and three lines on what you'd do next.

1. Install the free Arduino IDE from arduino.cc.
2. In Tinkercad, switch the code panel to Text and copy all the code.
3. Paste into a new Arduino IDE sketch. Pick Arduino Uno as the board and the USB port it's on.
4. Press Upload (the arrow). Copy the wiring exactly from your Tinkercad screen.

What's different in real life

• Wires come loose, and breadboard holes wear out. Push everything in firmly.
• Real buttons "bounce": one press can read as several. Add delay(50) after reading a press.
• Sensor readings wobble. Read several times and take the average.
• Parts really do burn out. Do the resistor sums every time.

A good first shopping list

Most Arduino starter kits include all of this: Arduino Uno (or a clone), USB cable, 830-hole breadboard, jumper wires, assorted resistors, LEDs, pushbuttons, a 10 kΩ potentiometer, a photoresistor, a piezo buzzer, an SG90 micro servo, an HC-SR04 ultrasonic sensor. Add a cheap multimeter.

Copy this into a note for each new project, yours or a learner's.

PROJECT:
In one sentence it...

INPUTS (what it senses):
OUTPUTS (what it does):

PARTS LIST:
Power: battery / USB / Arduino 5V
Resistor sums (R = (Vs - Vf) / I):

STEP 1  smallest version that works:
STEP 2  add:
STEP 3  add:

3D BODY:  size of the inside (mm) =
          gap for lids and fits = 0.3 mm

TESTS:  [ ] works in Tinkercad   [ ] works on breadboard
        [ ] fits in the case     [ ] someone else tried it

NEXT TIME I WOULD:

Four real design problems. Each one is a question you will hit as soon as projects get bigger.

Problem 1: three LEDs on 12 V

You want three red LEDs lit from a 12 V supply. Two ways to wire them:

The lesson: series uses a third of the current for the same light, but if one LED fails, all go out. Parallel is more robust but wastes more power as heat in the resistors. Never share one resistor between parallel LEDs: the LED with the lowest Vf hogs the current and burns out first.

Problem 2: switching a motor with a transistor

An Arduino pin gives 20 mA at most. A small motor wants 200 mA. A transistor acts as a switch: a small current into its base lets a big current flow from collector to emitter.

Problem 3: how long will the battery last?

Load values are typical. An Uno board alone draws around 45–50 mA. Servos draw far more while moving than while holding still. A NeoPixel can draw up to 60 mA at full white.

Problem 4: capacitor timing

A capacitor fills up through a resistor like a bucket under a tap that slows down as the bucket fills. The bigger the resistor and capacitor, the slower it fills. This is how simple circuits make delays and smooth out bumpy signals.

Small programs can use delay() and a few ifs. Bigger ones need these six patterns. The projects below use all of them.

1 · millis() instead of delay()

delay(1000) freezes the whole Arduino for a second. It can't read a button while it waits. millis() is a clock: the number of milliseconds since power-on. Check the clock instead of waiting, and the loop stays free to do other things.

unsigned long lastBlink = 0;
bool ledOn = false;

void loop() {
  if (millis() - lastBlink >= 500) {  // has half a second passed?
    lastBlink = millis();                // remember when
    ledOn = !ledOn;                      // flip on/off
    digitalWrite(13, ledOn);
  }
  // other jobs here run thousands of times a second
}

2 · Edge detection: "just pressed", not "held"

Reading a button tells you it's down. Often you want to act once, at the moment it goes down. Remember last time's reading and compare.

bool lastBtn = HIGH;

void loop() {
  bool btn = digitalRead(2);
  if (lastBtn == HIGH && btn == LOW) {   // was up, now down: the press moment
    mode = mode + 1;
  }
  lastBtn = btn;
}

3 · Debouncing

Metal contacts bounce for a few milliseconds when pressed, so one press can read as five. The easy fix: after you see a press, wait 20–50 ms before reading again. Tinkercad buttons don't bounce, but real ones do, so build the habit now.

4 · Hysteresis: two thresholds, not one

A fan that turns on above 28 °C and off below 28 °C will flick on and off all day when the room sits at 28 °C. Use a gap: on above 28, off below 25. Your home heating thermostat does this.

if (!fanOn && temp > 28) fanOn = true;
if ( fanOn && temp < 25) fanOn = false;

5 · Arrays for many pins

Four LEDs means four pins. Put them in a list and loop, instead of writing everything four times.

const int LEDS[4] = {8, 9, 10, 11};
for (int i = 0; i < 4; i++) pinMode(LEDS[i], OUTPUT);

6 · State machines

A machine that behaves differently at different times (waiting, playing, game over) is easiest to write as states. One variable says which state you're in. Each state has its own small block of code, and decides when to move to the next one.

enum State { WAITING, PLAYING, GAME_OVER };
State state = WAITING;

void loop() {
  switch (state) {
    case WAITING:
      if (buttonPressed()) state = PLAYING;
      break;
    case PLAYING:
      // game code
      if (lost) state = GAME_OVER;
      break;
    case GAME_OVER:
      showScore();
      state = WAITING;
      break;
  }
}

advanced Four coloured lights play a pattern. Copy it with four buttons. Every round adds one more step and plays a little faster.

New ideas: arrays, functions, random numbers, a growing sequence, and a game loop.

const int LEDS[4]    = {8, 9, 10, 11};
const int BUTTONS[4] = {2, 3, 4, 5};
const int NOTES[4]   = {262, 330, 392, 523}; // C, E, G, high C
const int BUZZ = 12;
const int MAX_STEPS = 50;

int sequence[MAX_STEPS];   // the pattern so far
int level = 0;              // how long the pattern is

void setup() {
  for (int i = 0; i < 4; i++) {
    pinMode(LEDS[i], OUTPUT);
    pinMode(BUTTONS[i], INPUT_PULLUP);
  }
  randomSeed(analogRead(A0));   // unconnected pin = random noise = new game each time
  Serial.begin(9600);
}

void loop() {
  if (level == 0) {             // a new game is starting
    for (int i = 0; i < 4; i++) flash(i, 120);
    delay(600);
  }

  sequence[level] = random(4);    // add one new random colour (0 to 3)
  level++;
  playSequence();

  for (int i = 0; i < level; i++) {   // now the player copies it
    int pressed = waitForButton();
    flash(pressed, 200);
    if (pressed != sequence[i]) {
      gameOver();
      return;                      // back to the top of loop()
    }
  }

  if (level == MAX_STEPS) {        // beat all 50: you win
    Serial.println("You win!");
    level = 0;
  }
  delay(700);
}

void flash(int n, int ms) {      // light + note for one colour
  digitalWrite(LEDS[n], HIGH);
  tone(BUZZ, NOTES[n], ms);
  delay(ms);
  digitalWrite(LEDS[n], LOW);
  delay(80);
}

void playSequence() {
  int speed = max(150, 500 - level * 20);  // faster each round
  for (int i = 0; i < level; i++) flash(sequence[i], speed);
}

int waitForButton() {              // stays here until a button is pressed
  while (true) {
    for (int i = 0; i < 4; i++) {
      if (digitalRead(BUTTONS[i]) == LOW) {
        delay(20);                                  // debounce
        while (digitalRead(BUTTONS[i]) == LOW) { }   // wait for release
        return i;
      }
    }
  }
}

void gameOver() {
  Serial.print("Game over. Score: ");
  Serial.println(level - 1);
  tone(BUZZ, 110, 800);
  for (int k = 0; k < 3; k++) {           // flash everything 3 times
    for (int i = 0; i < 4; i++) digitalWrite(LEDS[i], HIGH);
    delay(150);
    for (int i = 0; i < 4; i++) digitalWrite(LEDS[i], LOW);
    delay(150);
  }
  level = 0;
  delay(1000);
}

How it works

1. sequence is a list that remembers every colour so far. Each round adds one random number from 0 to 3.
2. playSequence() plays the whole list back. The gap shrinks by 20 ms a round, down to 150 ms.
3. The for loop asks for one press per step. waitForButton() sits in a loop until any button goes LOW, then returns which one (0–3).
4. One wrong press calls gameOver(), which resets level to 0, so the next loop() starts a fresh game.

advanced Type a code on a 16-key keypad. The screen shows stars as you type. The right code turns a servo to open a latch. Three wrong codes lock it for 30 seconds.

New ideas: a 16 × 2 LCD screen, reading a key matrix by hand, text strings, and a lock-out timer.

How a keypad matrix works

16 keys would need 16 pins. A matrix needs only 8. The keys sit where 4 row wires cross 4 column wires. Pressing a key joins its row to its column. The code switches on one row at a time (by pulling it LOW) and checks which column goes LOW with it. Row 2 + column 3 = key "6".

#include <LiquidCrystal.h>
#include <Servo.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);   // RS, E, D4, D5, D6, D7
Servo latch;

const int ROWS[4] = {10, 9, 8, 7};
const int COLS[4] = {6, A1, A2, A3};
const char KEYS[4][4] = {
  {'1', '2', '3', 'A'},
  {'4', '5', '6', 'B'},
  {'7', '8', '9', 'C'},
  {'*', '0', '#', 'D'}
};
const int GREEN = A4, RED = A5, SERVO_PIN = 13;

const String SECRET = "2580";   // change me
String entry = "";                // what has been typed so far
int wrongTries = 0;

void setup() {
  for (int r = 0; r < 4; r++) { pinMode(ROWS[r], OUTPUT); digitalWrite(ROWS[r], HIGH); }
  for (int c = 0; c < 4; c++) pinMode(COLS[c], INPUT_PULLUP);
  pinMode(GREEN, OUTPUT);
  pinMode(RED, OUTPUT);
  latch.attach(SERVO_PIN);
  lcd.begin(16, 2);
  lockDoor();
}

void loop() {
  char key = getKey();
  if (key == 0) return;            // nothing pressed this time round

  if (key == '*') {                  // * clears
    entry = "";
  } else if (key == '#') {           // # = enter
    checkCode();
  } else if (entry.length() < 8) {
    entry += key;
  }
  showStars();
}

char getKey() {                       // scan the matrix once
  for (int r = 0; r < 4; r++) {
    digitalWrite(ROWS[r], LOW);          // switch this row on
    for (int c = 0; c < 4; c++) {
      if (digitalRead(COLS[c]) == LOW) {  // this column is joined to it
        delay(20);
        while (digitalRead(COLS[c]) == LOW) { }  // wait for release
        digitalWrite(ROWS[r], HIGH);
        return KEYS[r][c];
      }
    }
    digitalWrite(ROWS[r], HIGH);         // switch it off again
  }
  return 0;
}

void showStars() {
  lcd.setCursor(0, 1);                  // column 0, line 2
  lcd.print("                ");           // wipe the line (16 spaces)
  lcd.setCursor(0, 1);
  for (unsigned int i = 0; i < entry.length(); i++) lcd.print('*');
}

void checkCode() {
  if (entry == SECRET) {
    wrongTries = 0;
    openDoor();
  } else {
    wrongTries++;
    lcd.clear();
    lcd.print("Wrong code");
    digitalWrite(RED, HIGH); delay(1000); digitalWrite(RED, LOW);
    if (wrongTries >= 3) lockOut(30);
    lockDoor();
  }
  entry = "";
}

void openDoor() {
  lcd.clear();
  lcd.print("Welcome!");
  digitalWrite(GREEN, HIGH);
  latch.write(90);                       // latch open
  delay(5000);
  digitalWrite(GREEN, LOW);
  lockDoor();
}

void lockDoor() {
  latch.write(0);                        // latch shut
  lcd.clear();
  lcd.print("Code, then #");
}

void lockOut(int seconds) {
  for (int s = seconds; s > 0; s--) {   // count down on screen
    lcd.clear();
    lcd.print("Locked out");
    lcd.setCursor(0, 1);
    lcd.print(s);
    lcd.print(" s");
    digitalWrite(RED, HIGH); delay(500);
    digitalWrite(RED, LOW);  delay(500);
  }
  wrongTries = 0;
}

advanced Three sensors, three outputs, one screen. It waters the soil when dry, opens a vent when hot, turns on a lamp when dark, and logs everything as a spreadsheet table.

New ideas: several jobs at once with millis(), hysteresis, a transistor-driven motor, a safety cut-out, and data logging.

Pump wiring, step by step: motor + → 5V. Motor − → transistor collector. Transistor emitter → GND. Pin 6 → 1 kΩ → transistor base. Diode across the motor's two legs. Use Tool 13 to check the 1 kΩ.

#include <LiquidCrystal.h>
#include <Servo.h>

LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
Servo vent;

const int SOIL = A0, TEMP = A1, LIGHT = A2;
const int PUMP = 6, VENT_PIN = 9, LAMP = 10;

// Settings: tune them by watching the Serial Monitor
const int   DRY = 300, WET = 600;          // start / stop watering
const float HOT = 28.0, COOL = 25.0;     // open / close vent
const int   DARK = 250;                  // lamp on below this
const unsigned long MAX_PUMP = 10000;   // never pump more than 10 s
const unsigned long REST = 30000;       // then rest 30 s before trying again

int soil, light;
float tempC;
bool pumping = false, ventOpen = false;
unsigned long pumpStart = 0, restUntil = 0, lastRead = 0, lastScreen = 0;
int screen = 0;

void setup() {
  pinMode(PUMP, OUTPUT);
  pinMode(LAMP, OUTPUT);
  vent.attach(VENT_PIN);
  vent.write(0);
  lcd.begin(16, 2);
  Serial.begin(9600);
  Serial.println("seconds,soil,tempC,light");   // spreadsheet headings
}

void loop() {
  unsigned long now = millis();

  if (now - lastRead >= 1000) {     // job 1: every second, read and decide
    lastRead = now;
    readSensors();
    decide(now);
    logLine();
  }
  if (now - lastScreen >= 3000) {   // job 2: every 3 seconds, swap screens
    lastScreen = now;
    screen = 1 - screen;
    showScreen();
  }
  if (pumping && now - pumpStart >= MAX_PUMP) stopPump(now);  // job 3: safety
}

void readSensors() {
  soil  = analogRead(SOIL);
  light = analogRead(LIGHT);
  float volts = analogRead(TEMP) * 5.0 / 1024.0;
  tempC = (volts - 0.5) * 100.0;
}

void decide(unsigned long now) {
  // Water, with hysteresis: start when DRY, stop only when WET
  if (!pumping && soil < DRY && now >= restUntil) {
    pumping = true;
    pumpStart = now;
    analogWrite(PUMP, 200);              // about 80% speed
  }
  if (pumping && soil > WET) stopPump(now);

  // Vent, same idea with temperature
  if (!ventOpen && tempC > HOT)  { ventOpen = true;  vent.write(90); }
  if ( ventOpen && tempC < COOL) { ventOpen = false; vent.write(0);  }

  digitalWrite(LAMP, light < DARK ? HIGH : LOW);
}

void stopPump(unsigned long now) {
  pumping = false;
  analogWrite(PUMP, 0);
  restUntil = now + REST;
}

void showScreen() {
  lcd.clear();
  if (screen == 0) {
    lcd.print("Soil "); lcd.print(soil);
    lcd.setCursor(0, 1);
    lcd.print(pumping ? "Watering..." : "Pump off");
  } else {
    lcd.print("Temp "); lcd.print(tempC, 1); lcd.print(" C");
    lcd.setCursor(0, 1);
    lcd.print(ventOpen ? "Vent open" : "Vent shut");
  }
}

void logLine() {                          // one comma-separated row per second
  Serial.print(millis() / 1000); Serial.print(",");
  Serial.print(soil);               Serial.print(",");
  Serial.print(tempC, 1);           Serial.print(",");
  Serial.println(light);
}

How it works

1. There's no delay() in loop(). Three jobs each check the clock and only run when it's their turn. That's why the safety cut-out can stop the pump at any moment.
2. The pump starts below 300 and stops above 600. The big gap is hysteresis: no flicking on and off.
3. If the soil never gets wet (the tank is empty, or in Tinkercad nobody moves the slider), the pump stops after 10 s and rests for 30 s. Real machines always need a "what if the sensor lies" plan.
4. The Serial Monitor prints a comma-separated table. Copy it into a spreadsheet and make a chart.

advanced A knob sets the speed. A button reverses the motor, slowing it to a stop first so the gears don't crunch.

New ideas: the H-bridge, a separate motor power supply, PWM speed control and ramping.

The H-bridge

To reverse a DC motor you reverse the current through it. An H-bridge is four switches arranged like the letter H, with the motor as the bar. Close the top-left and bottom-right switches and current flows one way. Close the other pair and it flows the other way. The L293D chip has two H-bridges inside.

The enable pin (EN) is the speed control. Feed it PWM: 255 is full speed, 0 is off.

Also: potentiometer middle leg → A0. Pushbutton between pin 2 and GND. Hover the chip's pins in Tinkercad to check the numbers; pin 1 is next to the notch.

const int EN = 5, IN1 = 7, IN2 = 8, BTN = 2, KNOB = A0;
bool forward = true;
bool lastBtn = HIGH;
int speedNow = 0;                    // what the motor is getting right now, 0 to 255

void setup() {
  pinMode(EN, OUTPUT);
  pinMode(IN1, OUTPUT);
  pinMode(IN2, OUTPUT);
  pinMode(BTN, INPUT_PULLUP);
  setDirection();
  Serial.begin(9600);
}

void loop() {
  bool btn = digitalRead(BTN);
  if (lastBtn == HIGH && btn == LOW) {   // the moment it's pressed
    rampTo(0);                          // slow to a stop first
    forward = !forward;
    setDirection();
    delay(200);
  }
  lastBtn = btn;

  rampTo(analogRead(KNOB) / 4);        // knob 0–1023 → speed 0–255
  Serial.println(speedNow);
}

void setDirection() {
  digitalWrite(IN1, forward ? HIGH : LOW);
  digitalWrite(IN2, forward ? LOW : HIGH);
}

void rampTo(int target) {              // change speed one step at a time
  while (speedNow != target) {
    speedNow += (target > speedNow) ? 1 : -1;
    analogWrite(EN, speedNow);
    delay(2);                         // 255 steps × 2 ms ≈ half a second
  }
}

advanced Press a button. A 7-segment display spins through numbers, slows down like a real die, and lands on 1 to 6. It uses only three Arduino pins for eight outputs.

New ideas: the 74HC595 shift register, sending data one bit at a time, and storing patterns as binary numbers.

What a shift register does

The 74HC595 turns 3 pins into 8 outputs. You send it 8 bits, one at a time, on the data pin. Each tick of the clock pin pushes the bits along one place, like people shuffling down a bench. When all 8 are in, one pulse on the latch pin copies them to the 8 outputs at the same moment.

Numbers as light patterns

The display has 7 bars named a to g. Each bar is one bit: 1 means lit. So each digit is just an 8-bit number.

const int DATA = 4, LATCH = 5, CLOCK = 6, BTN = 2;
// bit 0 = bar a ... bit 6 = bar g. Index = the digit.
const byte DIGITS[10] = {0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};

void setup() {
  pinMode(DATA, OUTPUT);
  pinMode(LATCH, OUTPUT);
  pinMode(CLOCK, OUTPUT);
  pinMode(BTN, INPUT_PULLUP);
  randomSeed(analogRead(A0));
  show(0);
}

void loop() {
  if (digitalRead(BTN) == LOW) roll();
}

void show(int n) {
  digitalWrite(LATCH, LOW);                      // hold the outputs still
  shiftOut(DATA, CLOCK, MSBFIRST, DIGITS[n]);    // send 8 bits, one per clock tick
  digitalWrite(LATCH, HIGH);                     // show all 8 at once
}

void roll() {
  int wait = 30;
  for (int i = 0; i < 15; i++) {       // spin, slowing down each time
    show(random(1, 7));                 // random(1, 7) gives 1 to 6
    delay(wait);
    wait += 15;
  }
  show(random(1, 7));                   // the final answer
  while (digitalRead(BTN) == LOW) { }    // wait for release
}

advanced A ring of 12 colour LEDs, each one separately controlled, on a single data wire. A button cycles through a rainbow, a spinner with a fading tail, and a level meter driven by a knob.

New ideas: addressable LEDs, colours as numbers (RGB and hue), animation frames with millis(), and a power budget.

#include <Adafruit_NeoPixel.h>

const int PIN = 6, COUNT = 12, BTN = 2, KNOB = A0;
Adafruit_NeoPixel ring(COUNT, PIN, NEO_GRB + NEO_KHZ800);

int mode = 0;                        // 0 rainbow, 1 spinner, 2 level meter
bool lastBtn = HIGH;
unsigned long lastFrame = 0;
unsigned long frame = 0;              // counts up every frame

void setup() {
  ring.begin();
  ring.setBrightness(80);              // out of 255: easier on eyes and power
  pinMode(BTN, INPUT_PULLUP);
}

void loop() {
  bool btn = digitalRead(BTN);
  if (lastBtn == HIGH && btn == LOW) { mode = (mode + 1) % 3; delay(30); }
  lastBtn = btn;

  if (millis() - lastFrame < 50) return;   // 20 frames a second
  lastFrame = millis();
  frame++;

  ring.clear();
  if (mode == 0) {                                  // rainbow wheel
    for (int i = 0; i < COUNT; i++) {
      uint16_t hue = i * 65536L / COUNT + frame * 512;  // hue goes 0 to 65535 round the wheel
      ring.setPixelColor(i, ring.ColorHSV(hue));
    }
  } else if (mode == 1) {                           // spinner with a fading tail
    for (int t = 0; t < 4; t++) {
      int i = (frame + COUNT * 10 - t) % COUNT;
      ring.setPixelColor(i, ring.Color(0, 0, 255 >> (t * 2)));  // 255, 63, 15, 3
    }
  } else {                                           // level meter
    int lit = map(analogRead(KNOB), 0, 1023, 0, COUNT);
    for (int i = 0; i < lit; i++) {
      if (i < 8)       ring.setPixelColor(i, ring.Color(0, 150, 0));    // green
      else if (i < 10) ring.setPixelColor(i, ring.Color(150, 120, 0));  // amber
      else              ring.setPixelColor(i, ring.Color(180, 0, 0));    // red
    }
  }
  ring.show();                                         // send the whole frame at once
}

The power budget

Each NeoPixel can draw up to 60 mA at full white (20 mA each for red, green and blue). 12 × 60 = 720 mA. A computer USB port usually gives 500 mA. So at full brightness this ring could brown out the Arduino. setBrightness(80) cuts the worst case to about 80 ÷ 255 of that: around 230 mA. For long strips, use a separate 5 V supply and join the grounds.

advanced Two trays joined by a hinge that prints already assembled, like a glasses case. It comes off the printer and folds shut straight away. No glue, no screws.

New ideas: clearance between moving parts, interlocking knuckles, and a hinge line placed so the halves close exactly.

Steps

1. Two trays: each 60 × 40 × 12 mm, hollowed with 2 mm walls and floor (as in D7 build 3). Call them A and B.
2. Place them side by side, open side up, with their long back edges facing each other and a 9 mm gap between them.
3. Knuckles: a row of 5 cylinders lying on their side along the gap: 8 mm across, 10 mm long each, with a 0.5 mm gap between neighbours. The row is 52 mm long. Centre it in the gap, with its centre line at 12 mm high, level with the tops of the walls. That height is what makes the two rims meet when it folds.
4. Join them alternately: each knuckle has 0.5 mm of air to each wall. Fill that air with a small bridge block on one side only: knuckles 1, 3, 5 to tray A, knuckles 2 and 4 to tray B.
5. Pin: a 3.5 mm cylinder running through all five knuckles. It belongs to tray A's side.
6. Clearance holes: in knuckles 2 and 4, add a 4.5 mm hole cylinder around the pin (3.5 + 2 × 0.5 = 4.5). Group each of these knuckles with its hole before grouping anything else.
7. Group tray A with knuckles 1, 3, 5 and the pin. Group tray B with knuckles 2 and 4. Do not group the two sides together, or the gaps get filled.
8. Export both sides as one STL, so they print in place. Turn supports off in the slicer, or support plastic will fill the hinge gaps.

advanced Two gears on a base plate, spaced so they mesh exactly. Turning the small one turns the big one slower but with more force.

New ideas: the gear module, centre distance, gear ratio, and trading speed for force.

Steps

1. Open Shape Generators and search "gear". Generators differ: some ask for the module, some for a diameter. Use the numbers from Tool 16 for either.
2. Make both gears 6 mm thick. Give each a 5.4 mm hole in the centre (a 5 mm pin + 0.4 mm clearance).
3. Base plate: a box, with two 5 mm cylinder pins 12 mm tall, exactly the centre distance apart, plus 0.2 mm extra so the printed teeth don't bind.
4. Add a small knob (a cylinder off-centre) on top of the driver gear so you can crank it.
5. Print the gears flat. Drop them onto the pins.

advanced A case for the A3 Simon game with an Arduino inside, four button holes and LED windows on top, a speaker grille, and a USB opening. This is where the circuit and 3D halves of the course meet.

New ideas: designing around real parts, mounting posts with screw holes, patterns of holes, and labels.

Measure first, design second

Sizes vary by maker. Use a ruler or calipers on your actual parts and trust that over this table.

Steps

1. Shell: outside 120 × 90 × 40 mm, hollowed with 2.5 mm walls. Leave the top open.
2. Mounting posts: four cylinders 6 mm across, 6 mm tall, on the floor, where the Uno's mounting holes are (measure them). Each gets a 2.5 mm hole for an M3 screw.
3. USB opening: line a box hole up with the board's USB socket in the end wall. Add 1 mm all round.
4. Top panel: 120 × 90 × 2.5 mm. Four button holes in a 2 × 2 grid, 30 mm apart. A 5.3 mm LED hole above each button.
5. Speaker grille: one 2 mm hole, then Ctrl + D, move 4 mm, Ctrl + D four more times. Select the row, Ctrl + D, move 4 mm down, repeat. A 5 × 5 grille in under a minute.
6. Labels: text 1 mm deep as a hole (engraved) reads better than raised text on a top panel.
7. Lid fit: add a lip under the top panel, 0.3 mm smaller than the opening on each side (D7 build 3).

advanced A twisted, bulging tower or vase made from 40 stacked layers. Change one number and the whole shape changes.

New ideas: variables that drive a design, loops with maths inside, and parametric design (shapes built from rules, not drawn by hand).

The rule for each layer

Blocks, in order

1. Create variables i and size. Set size to 30.
2. Count with i from 0 to 39 by 1. Inside it:
3. 1. Add a Box. Set its length and width to size, height 2.
   2. Move it up (Z) by i × 2.
   3. Rotate it around Z by i × 4 degrees.
   4. If i < 20, change size by 1. Else change size by −1.
4. Press Run. Watch it build layer by layer.
5. To make a vase, run the same loop a second time with each box 4 mm smaller, starting at height 2, and make those boxes holes. Group everything.

advanced One big project that uses everything. A printed hinged case stays locked until players solve three puzzles. Built by a team of 3–4 over five sessions. It also works as a solo project.

The puzzles

1. Light puzzle: shine a torch on a hidden photoresistor. A NeoPixel turns from red to green.
2. Knob puzzle: turn a potentiometer until a piezo's pitch matches a reference note. Hold it for 2 seconds.
3. Code puzzle: the first two puzzles each reveal one half of a 4-digit code on the LCD. Type it on the keypad. The servo latch opens.

Five sessions

// The skeleton: one state per puzzle (A2, pattern 6)
enum State { LIGHT_PUZZLE, KNOB_PUZZLE, CODE_PUZZLE, OPEN };
State state = LIGHT_PUZZLE;

void loop() {
  switch (state) {
    case LIGHT_PUZZLE: if (lightSolved()) { showHalfCode(1); state = KNOB_PUZZLE; } break;
    case KNOB_PUZZLE:  if (knobSolved())  { showHalfCode(2); state = CODE_PUZZLE; } break;
    case CODE_PUZZLE:  if (codeSolved())  { openLatch();      state = OPEN;        } break;
    case OPEN:         if (resetPressed()) { closeLatch();     state = LIGHT_PUZZLE; } break;
  }
}

Analog

A signal that can be any value in a range, like a dimmer.

Anode / cathode

The + and − legs of an LED or diode.

Breadboard

A board with joined holes for building circuits without solder.

Conventional current

Drawing current from + to −. Electrons really go the other way.

Digital

A signal that is only on or off: HIGH or LOW.

Export

Save a design as a file for another program or a printer.

FDM printer

The common 3D printer that melts plastic layer by layer.

Floating pin

An input connected to nothing. It reads random values.

Forward voltage (Vf)

The voltage an LED uses up when it's on.

GND (ground)

The 0 V, − side of a circuit.

AWG

Wire thickness. A bigger number means a thinner wire.

Continuity

Whether two points are joined. The multimeter's beep test checks it.

Header

A strip of pins (male) or sockets (female) at 2.54 mm spacing.

JST

A family of small keyed plastic plugs, used on batteries and sensors.

Junction rule

Current flowing into a point equals current flowing out.

Keyed

Shaped so it only fits one way round.

kWh

Kilowatt-hour: 1,000 W for one hour. The unit on the electricity bill.

Loop rule

The voltages round a loop add up to the supply.

mAh

Milliamp-hours: how much charge a battery holds.

Pitch

Centre-to-centre spacing of pins. Usually 2.54 mm.

Tinning

Coating a wire end or soldering tip with a thin layer of solder.

H-bridge

Four switches around a motor so it can turn both ways.

Hysteresis

Using two thresholds (on at one, off at another) to stop flicking.

millis()

The Arduino's clock: milliseconds since power-on. Lets code wait without freezing.

Module (gears)

Tooth size. Gears only mesh if their modules match.

Shift register

A chip that turns 3 pins into 8 outputs by taking bits in one at a time.

State machine

Code organised as named states and the rules for moving between them.

Time constant (τ)

R × C: how quickly a capacitor fills.

Transistor

An electric switch: a small current controls a big one.

Group

Join shapes into one. Holes cut when grouped.

Microcontroller

A tiny computer on a chip, like the Arduino's.

Overhang

Part of a print with nothing under it.

Parallel

Parts side by side, each with its own path.

Polarity

A part that only works one way round has polarity.

Pull-up resistor

Holds an input at HIGH until a button pulls it LOW.

PWM

Switching a pin on and off fast to fake in-between levels.

Series

Parts one after another, on one path.

Serial Monitor

A window showing text sent by the Arduino.

Short circuit

A path with almost no resistance. Huge current, heat.

Slicer

Program that turns an STL into printer instructions.

STL

The most common 3D-printing file type.

Tolerance

How far a real part can be from its stated value, like ±5%. In 3D printing, the gap left so parts fit.

Workplane

The flat surface new shapes sit on.