Embedded Systems and Microcontrollers

Voltage is electrical push, measured between two points. A single AA cell pushes with 1.5 volts. Two of them in a line push with 3 volts. The board here runs on 3.3 volts, which is a small, safe push: you can hold both rails at once and feel nothing at all.

Push on its own moves nothing. Current is what flows when the push has somewhere to go, and it is measured in amps, or more usefully for small parts in milliamps, thousandths of an amp. A pin can supply roughly 20 milliamps before it complains, which is enough for an indicator lamp and nowhere near enough for a motor. That gap is the whole of Step 8.

A bit is one thing that has two possible states, written 0 and 1. A light switch is a bit. A pin held low or high is a bit. One bit on its own can only ever say one of two things, so bits are used in groups.

Eight bits side by side is called a byte. Eight switches with two settings each give 2 x 2 x 2 x 2 x 2 x 2 x 2 x 2 = 256 different patterns. So a byte can hold any whole number from 0 to 255. The second lab in this step builds a byte out of eight real pins, one voltage each.

The lamp here is an LED, a part that gives out light when current runs through it the right way. An LED has no sense of moderation: offer it more current and it takes more, until it destroys itself. So a resistor goes in the path to limit how much current can flow. Resistance is measured in ohms, and the standard part for this job is 220 ohms.

The arithmetic is one division. An LED drops about 2 volts across itself, leaving 1.3 volts of the 3.3 to push current through the resistor. Current equals volts divided by ohms, so 1.3 divided by 220 gives about 0.006 amps, which is 6 milliamps. Comfortably bright, and comfortably inside what a pin can give. The lab shows that number as you toggle the pin.

Hertz means once per second. A kilohertz is a thousand times a second and a megahertz is a million times a second. A board at 16 megahertz takes sixteen million small steps every second, and each step does a tiny piece of work such as adding two numbers or fetching one from memory.

Sixteen million sounds like plenty, and for blinking a lamp it is absurdly more than enough. It runs out when you ask for arithmetic on every one of a thousand sensor readings a second, or when you want a screen redrawn smoothly. Most beginner projects never notice the difference between 16 and 240.

Flash keeps what is written in it with no power, like a notebook. That is where your program lives, so the board still knows what to do when you plug it in tomorrow. Writing to flash is slow and it wears out after many thousands of rewrites, so a program is written once when you upload it and then only read.

RAM forgets everything the moment the power goes, like a whiteboard, and in exchange it is fast and can be rewritten endlessly. Every value your program keeps while it runs lives there. RAM is the number that usually runs out first: 2 kilobytes, which is 2048 bytes, disappears quickly once you want to remember a few hundred sensor readings.

A milliamp is a thousandth of an amp. A microamp is a millionth of an amp, so a thousand microamps make one milliamp. Battery size is quoted in milliamp hours: a coin cell holds about 220 milliamp hours, meaning it can give 220 milliamps for an hour, or 1 milliamp for 220 hours, and so on.

Now the arithmetic. A board that draws 30 milliamps flattens that coin cell in about seven hours. A board that sleeps at 10 microamps, which is 0.01 milliamps, would take 22000 hours, which is over two years. Same job, same cell, and the only thing that changed was one column in the table below.

A function is a piece of program with a name on it. Everything between the two curly brackets belongs to it. Writing delay(400) means run the function called delay, and hand it the number 400 to work with. The things handed over go in the round brackets, and the function does something with them.

Here setup and loop are two functions you write and never call yourself. The board calls them for you, which is the whole arrangement: you fill in what should happen once and what should happen forever, and the board does the calling.

One instruction is called a statement, and a semicolon marks the end of one, the way a full stop marks the end of a sentence. Curly brackets { and } group statements together so a function can hold several. Round brackets hold the values being handed to a function, and stay there even when there is nothing to hand over, as in millis().

A line starting // is a comment. Everything after the two slashes is for people to read and is ignored completely by the machine, so a comment is free and cannot break anything. The starting sketch below has a comment where a missing line should be.

A thousandth of a second. Blinking your eye takes about 150 of them. delay(400) tells the board to stand still and do nothing for 400 thousandths of a second, a little under half a second. That is slow enough for a person to see the lamp change.

Later steps also use the microsecond, a millionth of a second, because that is the scale a switch bounces at and the scale a servo pulse is measured in. A thousand microseconds make one millisecond.

A single = puts a value into a name: count = 0 means make count hold zero. Three of them is a question rather than an order. digitalRead(2) === LOW asks whether those two things are the same, and the answer is either true or false. Using one where you meant three is a classic bug, which is why the question form is deliberately different to look at.

if takes such a question and runs the block after it only when the answer is true. else supplies a block to run instead when the answer is false. So an if with an else always runs exactly one of the two blocks, never both and never neither.

A pull-up is a resistor from the pin up to the 3.3 volt rail. While the button is open it is the only thing connected to the pin, so it holds the pin high and the reading is a steady 1. It works because nothing needs to flow: the pin is only listening, so a very weak connection is plenty.

Press the button and the pin now has two things attached: 10000 ohms up to 3.3 volts, and near zero ohms straight down to ground. The direct path wins, and the pin sits at 0 volts. A tiny current trickles down through the resistor while you hold it, about a third of a milliamp, which is why the resistor is chosen large. Most chips have such a resistor built in, switched on by asking for INPUT_PULLUP instead of INPUT. Then you need no extra part at all.

It is backwards, and it is normal. With a pull-up the resting state is high, so pressing is the thing that pulls the pin down. Open reads 1, pressed reads 0. Nothing is wrong with the wiring and nothing can be done about it except to write the code that matches.

You could wire it the other way, with a pull-down resistor to ground and the button going up to 3.3 volts, and then pressed would read 1. Almost nobody does, for one reason: the pull-up is already inside the chip and free and the pull-down is not. A whole industry reads its buttons upside down to save a part.

A name that holds a number, and a line that replaces what it holds with one more than that. count = count + 1 reads the current value, adds one, and puts the result back under the same name. The name is called a variable, because what it holds varies.

A counter declared outside every function, at the top of the sketch, keeps its value between one pass through loop and the next. One declared inside loop would be created fresh each pass and would never get past 1, which is a bug worth knowing about before you write it.

Because the contacts are springs. They have to be, or they would not push back against each other hard enough to make a reliable connection. A spring that arrives at a stop does not simply stay there, it rebounds, and while it is in the air the circuit is open again.

The bouncing dies away as the energy goes, which is why the gaps in the lab below get shorter each time. Bigger switches bounce for longer, worn ones bounce worse than new ones, and no switch has a published bounce time you can rely on. That is the point: this is a physical effect you design around rather than a number you look up.

The fix is a lockout: the moment you believe the pin has changed, stop looking at it for a while. That covers the way back up as well, because letting go bounces too. Too short a lockout and bounces slip through, so a counter reads six for four presses. That is annoying and obvious, and whoever is testing it notices immediately.

Too long a lockout swallows real presses that happen close together, so the counter reads three for four presses. Nothing on screen looks wrong, no reading is impossible, and the missing press leaves no trace. A bug that produces a plausible wrong answer survives testing much longer than one that produces an obviously wrong one.

Your eye adds up light over a short window, roughly a fiftieth of a second, and reports the total. Anything that flashes faster than that arrives inside one window and gets averaged. A lamp that is on for half of every cycle delivers half the light, and half the light is what you see: a steady dim lamp.

Below about 25 cycles a second the flashing lands in separate windows and you see it as flicker. This is not a property of the lamp, it is a property of you, which is why the lab lets you drag the frequency down until your own eye gives up.

Because the setting is stored in one byte, and a byte holds 0 to 255. That is the natural size for the hardware that makes the pulses, so it is the size the function takes. 0 means never on. 255 means always on. 128 means on for a hair over half of each cycle, because 128 out of 255 is a shade more than half.

Doing the sum the other way is worth a moment: 200 out of 255 is about 78 hundredths, so analogWrite(9, 200) averages about 78 hundredths of 3.3 volts, which is 2.6 volts. The pin never once visits 2.6 volts. That is what the average of a square wave means.

let b = 0; makes a new name and puts zero in it. Names made with let inside a function exist only while that function is running, which is fine for something being counted up right now and wrong for something that has to be remembered between passes.

while (b <= 250) { ... } runs the block, checks the question again, and keeps going for as long as the answer is true. Something inside the block has to move towards making it false, or the loop never ends. In the fade below, that something is b = b + 10, which is what eventually pushes b past 250 and lets the loop finish.

Only in that you are paying attention to how long it lasts. A pulse is a pin taken high and then put back low, and its width is the time it spent high. Setting a pin high and leaving it there is a pulse that has not ended yet.

What makes it useful is that time is easy to measure precisely and voltage is not. A wire loses a little voltage along its length and gains a little noise from its neighbours, but 1.5 milliseconds is 1.5 milliseconds at both ends of the wire. Sending information as a duration rather than as a level is a trick that turns up everywhere once you have seen it.

Because the servo forgets. Its controller expects a fresh instruction every 20 milliseconds or so, and after about a tenth of a second of silence it stops pushing and goes limp. That sounds like a flaw and is a safety feature: a servo that lost its signal wire would otherwise keep straining against whatever it was last told, quietly cooking itself.

The repetition is also what lets a servo hold against a push. Each new pulse is compared with where the shaft actually is, and if a hand has moved it, the controller drives it back. A plain motor told to move and then left alone has no idea it has been pushed.

A small hobby servo pulls a few hundred milliamps while moving and can spike over an amp when it is pushing against something. A pin can supply about 20. Powering a servo from a pin does not work at all. Powering one from the board's own supply usually drops the whole rail far enough to reset the chip, which looks like a firmware bug and is not one.

So the servo takes its power and ground straight from a supply, and only its signal wire goes to a pin. The one wire that must be shared is ground. Two circuits with no common ground have no agreement about what 0 volts means, so the servo cannot tell how high your pulse is.

You are made of them. A transistor is the same part your processor is built out of, in its millions, switching billions of times a second. The ones in a bridge are simply much bigger, because a switch that carries an amp has to be built to carry an amp, while a switch that only feeds the next switch does not. Same idea, wildly different size.

Q is the traditional letter for a transistor on a wiring diagram, which is why the four are Q1 to Q4 rather than S1 to S4. In a real project you rarely wire four of them yourself. You buy a driver chip with all four inside, and the reason is in the next two notes.

A coil with current running through it stores energy in a magnetic field, and it will do whatever it takes to keep that current flowing for a moment longer. This property is called inductance, measured in henries and a small motor's winding is about 0.0015 henries.

The voltage it produces is the inductance multiplied by how fast the current changes. Stop 0.9 amps in about a millionth of a second and that comes out at over a thousand volts, appearing across the switch that just opened. A transistor rated for 40 volts does not survive that, and the failure happens at switch-off rather than during running, which is why it is so puzzling the first time.

A diode is a one way valve for current. Fitted across each switch the wrong way round for normal operation, it does nothing at all while the circuit is running. The instant a switch opens and the coil starts pushing, the diode becomes the easiest path available and the current runs round through it instead, dying away in the resistance of the winding.

With that path available the coil never has to produce a big voltage, because it never has to force current through anything that is refusing to carry it. The spike stops at about a volt above the supply. The lab shows both cases, and shows the number.

A coil is a length of wire wound many times round a core of iron. Current through wire makes a magnetic field, and winding the wire into many turns stacks those fields on top of each other, so a modest current makes a strong magnet. Switch the current off and the magnet vanishes.

That switchable magnet is the whole trick of every motor in this course. In a stepper it pulls the permanent magnet in the middle round to face it. In the DC motor of Step 8 the same coils are switched automatically by brushes as the shaft turns, which is why that one spins continuously instead of stepping.

Energise two neighbouring coils at once and the magnet cannot face either, so it settles halfway between them. Alternating single coils with pairs gives twice as many resting places: eight rows in the table instead of four, 400 steps a turn instead of 200, and each step 0.9 degrees instead of 1.8.

It is not free. A half step position is held by two coils pulling sideways at each other, so it has less holding force than a full step, and the strength of the steps now alternates. Real controllers push this much further with microstepping, feeding the coils partial currents to place the magnet anywhere, and each subdivision buys smoothness and loses grip.

It does not, and it cannot work it out. Counting steps tells you how far you have moved from where you began. Nothing at all about where that was. Power a plotter on and the head could be anywhere.

So real machines home first. They drive slowly towards one end until a switch is pressed, then call that position zero and count from there. Every trip your printer makes to the far left with a clunk before it starts printing is exactly this. One cheap switch buys the one piece of information counting cannot supply.

Because the converter works in bits. Ten bits give 2 multiplied by itself ten times, which is 1024 different values, numbered 0 to 1023. A converter with 12 bits, which many newer boards have, gives 4096 values numbered 0 to 4095. The count is always a power of two because that is what a row of bits counts.

One step is therefore 3.3 volts divided by 1024, about 3.2 thousandths of a volt. The converter cannot see anything finer than that, so two voltages 1 thousandth of a volt apart come back as the same number. Every measurement in every computer has a step size like this hiding in it.

Say the sensor is at 10000 ohms and the fixed resistor is also 10000. The two are equal, so they share the 3.3 volts equally and the joint sits at 1.65 volts. That is 1.65 divided by 3.3, which is half of the range, so analogRead answers about 512.

Now the room brightens and the sensor drops to 2000 ohms. The fixed resistor is now five times the bigger share, so the joint rises to 3.3 multiplied by 10000 divided by 12000, which is 2.75 volts, and the reading climbs to about 853. The general form is the supply multiplied by the lower resistor divided by both added together and the lab prints exactly that sum as you drag.

The divider is most sensitive when the two resistances are similar, and goes flat when one is far bigger than the other. Fit a 1000 ohm resistor against a sensor that sits at 10000 in the range you care about and almost the whole voltage lands on the sensor, so the reading barely moves as the light changes.

So the fixed resistor is chosen to be about the sensor's resistance in the middle of the range you actually want to measure. Getting that wrong squashes the interesting part of the range into a handful of numbers, and no amount of programming can recover a spread the circuit never produced.

A number written in sixteens instead of tens. Ordinary counting has ten symbols, 0 to 9, and each place to the left is worth ten times the one on its right. Hexadecimal has sixteen symbols: 0 to 9, then A for ten, B for eleven, C, D, E and F for fifteen. Each place to the left is worth sixteen times the one on its right, and the 0x at the front is a label saying which system this is.

So 0x76 is seven sixteens and six ones, which is 112 plus 6, which is 118. Datasheets use hexadecimal because one hexadecimal symbol is exactly four bits, so 0x76 is also the bit pattern 0111 0110 read straight off. The sketch below uses 118 and 250 where the datasheet says 0x76 and 0xFA, and they are the same numbers.

A register here is a numbered pigeonhole inside the sensor, each one holding a single byte. Register 0xD0 holds a fixed number identifying what kind of chip this is, which is how a program checks it is talking to what it thinks it is. Registers 0xFA and 0xFB hold the latest temperature. Other registers hold settings you write to rather than read.

Reading a register does not consume it or change it. Ask twice and you get the same byte twice, unless the sensor has taken a new measurement in between. That is different from a queue, where reading takes an item away, and it is worth being clear which kind of thing you are reading from.

Because a register holds one byte, and a byte can only hold 0 to 255. The sensor wants to report 2137, meaning 21.37 degrees, and 2137 does not fit in a byte. So it splits the number: the top part goes in one register and the bottom part in the next.

Putting it back together is the same idea as reading a two digit number, except the base is 256 instead of 10. In 47, the 4 means four tens. Here the top byte means that many 256s. So the whole number is the top byte multiplied by 256, plus the bottom byte. For 2137 that is 8 lots of 256, which is 2048, plus 89, and 8 and 89 are exactly what the two registers hold.

The chip stops it mid-sentence. It writes down where it had got to and every number it was holding at that moment, jumps to your function, runs it, then puts all of that back exactly as it was and carries on from the next instruction. The interrupted code has no way of telling that anything happened.

The function that gets run is called an interrupt handler, or an interrupt service routine, which is why you see ISR in other people's code. You never call it yourself. You hand its name to attachInterrupt, with no brackets after the name, because you are naming the function rather than running it.

Because while it runs, the rest of the machine is standing still. The main program is paused, and on most chips other interrupts are held off too, including the one that advances the millisecond counter. Time itself stops being counted properly.

So a delay inside a handler is a trap: the delay waits for a clock that is not moving, and never ends. The rule is to get in, change one thing, and get out. A handler that sets a variable to say something happened, leaving loop to do the actual work when it gets round to it, is the normal shape.

An interrupt fires on an edge, meaning a moment when the level changes, and you choose which kind. RISING is the moment the pin goes from low to high. FALLING is high to low. CHANGE is either.

With a pull-up button, pressing is the falling edge and releasing is the rising one, so FALLING gives one call per press and CHANGE gives two. Picking CHANGE by accident is the reason a counter sometimes reads exactly double, which the checker in the second lab will tell you about if you try it.

From a counter in hardware that ticks along on its own, driven by the same crystal that clocks the processor. It counts whether your program is busy or not, which is what makes it trustworthy. Reading it costs almost nothing: it is a fetch, not a measurement.

It starts at zero when the board powers up, so the number is not a time of day, it is an age. It also keeps counting during delay, which is a useful thing to know: a delay does not stop the clock, it only stops your program from looking at it.

Because you will not be looking at the exact millisecond. loop arrives whenever it arrives, and if some other job took a moment you might glance at 124 and then at 127. Testing for equality would miss 125 entirely and the lamp would never blink again.

Asking whether at least 125 have gone by can never miss. It fires on the first pass at or after the target, which may be a fraction late, and then the note is updated so the next one is measured from there. That single greater-or-equal is the difference between a lamp that blinks forever and one that stops the first time the board is busy.

Flipping a value between 0 and 1 without an if. If on13 holds 0, then 1 minus 0 is 1. If it holds 1, then 1 minus 1 is 0. Assigning that back gives the opposite of what was there.

Since digitalWrite treats 0 as low and anything else as high, the same variable can be both the remembered state and the value written to the pin. Keeping a note of the state matters here: with no delay to structure the code, the program has to remember whether the lamp is currently on, because nothing else does.

Because a stuck program is not executing any code that could do the checking. Whatever watchful function you write is stuck in the same place as everything else. The watch has to be kept by something that is not the program.

So the watchdog lives in hardware, alongside the processor rather than inside its instruction stream, and on most chips once it is switched on nothing in software can switch it off again. That refusal is deliberate: a bug that could disable the watchdog would take the safety net with it.

Somewhere the program only reaches when it is healthy. The top of loop is the usual place, because arriving there means the last pass finished. Petting from several places so that some path always reaches one is how you defeat your own watchdog.

Two placements are worse than useless. Petting inside the loop that is stuck keeps the board alive while it does nothing at all. Petting from a timer interrupt does the same, since interrupts often keep running while the main program is jammed, and then the watchdog reports a healthy board forever.

Everything in RAM. Every pin drops back to being an input at 0 volts, every variable loses its value, and setup runs again from the top as if the power had been cycled. The program in flash is untouched, which is why the board comes back rather than coming back empty.

So a design that survives a watchdog reset has to survive starting over halfway through whatever it was doing. A motor stops, which is usually right. A counter of how many bottles have passed is lost, which may not be, and if it matters it has to be written somewhere that survives a reset.

Much quicker, and that is the problem. Light crosses a room in about a hundred millionth of a second. Timing that needs a clock ticking billions of times a second, and parts that fast cost more than the rest of the robot put together. Sound is close to a million times slower than light, which turns the same job into something a cheap chip can do.

Crossing a room and coming back takes sound thousands of microseconds, and counting microseconds is what the hardware timer from Step 13 does without being asked twice. Sensors that time light do exist and they cost far more, because the hard part was never making the flash. It was catching it.

The clock starts when the burst leaves and stops when it gets back, so what it timed was a there and back trip. Walk to a shop and home again and you have walked twice as far as the shop is away. Nothing at the far end can tell the sensor when the sound arrived there, so half a trip is not something it can time. It times the whole thing and you halve the answer.

This is the most common mistake in this step and it has a signature. Every reading comes out exactly twice what a tape measure says. If your numbers are all double, you have not halved. If they are all half, something is halving twice.

Nothing. pulseIn sits on the echo pin and does not hand control back until the pin falls or the wait runs out. That makes it a blocking call, the same trouble delay caused in Step 13. While it sits there no other job in loop gets a turn, and a button press can come and go unnoticed.

So the length of the wait is a real cost and not just a safety net. Every reading with no echo in it spends the whole wait doing nothing at all. A robot taking ten readings a second with a generous wait can spend most of its life listening for sounds that are not coming. Make the wait long enough for the furthest thing you need to see, and no longer.

Yes, a little. Sound moves faster in warm air than in cold, by roughly 0.6 metres a second for every degree. The 343 in the sum is the speed in a room at about 20 degrees. On a hot day at 30 degrees the sound is about 6 metres a second quicker. That is under 2 hundredths of the whole speed, so a distance worked out with the room temperature number is under 2 hundredths wrong. Multiply that by the distance you care about and you have the error in centimetres.

Careful ultrasonic measurement puts a thermometer beside the sensor and corrects the speed before doing the sum. For a robot trying not to hit a chair leg, nobody bothers. The next lab shows why: the surface you are pointing at will let you down long before the temperature does.

By taking turns, and by agreeing on time rather than on voltage. A slot is a short fixed stretch of time, and the board opens each one by pulling the line down. For a 1 the sensor lets go immediately and the pull-up drags the line back up. For a 0 the sensor keeps holding it down until the slot is nearly over. The board looks part way through the slot: still low is a 0, already back up is a 1.

The pull-up in the picture below is 4.7 kilohms, which is 4700 ohms, since kilo means a thousand here exactly as it did in kilohertz in Step 2. It is the part that makes sharing possible. Both ends can pull the line down and neither has to push it up, so the two can never fight over the wire. The sensor sends its lowest bit first, which is why the eight bits under the trace read right to left.

No, and telling apart the two ways they jump is most of this step. The first is everyday wobble: every reading is a little out, up or down, by roughly the same small amount. Some of that is the air really stirring next to the sensor. Some is electrical hum picked up on the wire. Some is the sensor having to choose one of its sixteenths when the truth sits between two of them.

The second is a reading that comes back far out and is back to normal immediately after. Nothing in a room warms by several degrees and cools again in a tenth of a second, so a reading like that is not about temperature at all. A bit got knocked over on the wire, or the sensor was disturbed part way through answering. The labs below call those wild readings, and no amount of careful averaging will make one of them true.

Because it has nothing but readings that have already happened. Take the average of the last five. Those five are spread over five readings' worth of time, and the middle of that stretch is two readings back. So the answer describes the room as it was two readings ago rather than now. Widen the window and the middle of it moves further into the past.

While nothing is changing, being late costs nothing: the past and the present are the same number. The bill arrives when the thing you are measuring really moves. Part way through the run in the second lab a hand closes round the sensor and the temperature climbs for real. A slow filter is still reporting the cold room while the hand is on it, and that is what makes the choice of window a decision rather than a preference.

Step 2 counted a board's RAM in kilobytes, and a small one has about two of them, which is 2048 bytes for everything the program is holding at once. A window of twenty-one readings means keeping twenty-one numbers and shuffling them along as each new one arrives. For one temperature that is nothing. For a dozen sensors, each with its own window, it stops being nothing.

The fading average never keeps a list. It holds its own last answer, takes one new reading, works out the next answer from those two, and forgets both of the old numbers. Its proper name is the exponential moving average, and that is all the name means: old readings fade away instead of dropping out all at once. It is the filter you find inside firmware that has no room to spare and the second lab measures how close its answer stays to the other two.

Because holding something up is a push. The table pushes the chip upwards hard enough to stop it falling, and the weight inside has to be pushed up with it. The springs bend to do that pushing and the bend is what gets measured. The size of that bend, for anything held still at ground level, is what one g means.

Take the table away and the reading goes. A sensor dropped in mid-air reads nothing on any axis while it falls: nothing is holding the weight up any more, so no spring is bent. That is not a fault, and it is how a phone can tell it has been dropped before it lands. Every sensor in orbit reads the same, which is the real reason things float up there.

Lay the board flat and gravity pulls straight through it. The axis through the board reads about 1 g, and the axis along it reads about nothing. Stand the board on its edge and the two swap over. Tip it part way and the pull is shared between them and the way it is shared is the angle. The lab draws both readings as arrows out of the middle of the sensor, each one as long as the number it stands for. Watch the pull move from one axis to the other as the board turns.

Turning that pair of numbers into degrees is one line in any language. The function that does it is called atan2, and you hand it the two readings and it answers with the angle. You do not need to know how it works to use it, any more than you need to know how a square root button works. Sensors sold today have three axes rather than two, which is what lets a device tell tipping forwards from tipping sideways.

You can, and every serious sketch does. Hold the board still at power-up, average a few hundred readings, and whatever comes out is roughly what the chip reads while nothing is turning. Subtract that from every reading afterwards. It helps a great deal.

It does not fix the problem. The leftover moves as the chip warms up, so a number measured at breakfast is wrong by lunchtime. Whatever is left after subtracting still gets added up fifty times a second: an error of a hundredth of a degree per second is a whole degree after a hundred seconds, and two degrees after two hundred. The measurement also goes badly wrong if the board happened to be moving while you took it, since then you have recorded the movement and called it error. And a gyroscope only ever knows how far it has turned from wherever it started. Nothing in it knows which way down is, so sooner or later you have to ask the other chip.

Nearly. Step 16 moved its answer a fixed fraction of the way towards each new reading of one sensor, to smooth out noise. This moves its answer a fixed fraction of the way towards a second sensor, to correct a slow error the first sensor cannot see. Same arithmetic, different job.

The name says how the two parts fit: w of the accelerometer and 1 minus w of the gyroscope, every reading, adding up to one whole answer with nothing left over and nothing counted twice. A cleverer version called the Kalman filter chooses the weight for itself, from how noisy each chip has been lately. That is what a drone or a phone actually runs, and it is this idea with the weight no longer a number you picked by hand.

They are descriptions rather than brand names, and each one tells you the shape. DIP is dual in-line package: two parallel rows of legs, made to go through holes. SOIC is small outline integrated circuit, the same two rows shrunk and bent outwards to sit on top of the board instead. TSSOP is thin shrink small outline package, which is that idea shrunk again.

QFN is quad flat no-lead: four sides, flat, and no legs sticking out, because its metal is a ring of pads on the underside. BGA is ball grid array. It has no edge of pads at all, only a field of solder balls underneath, in rows and columns like squares on a chessboard. The number after the name counts the connections, so a DIP-28 has twenty-eight legs and a BGA-144 has one hundred and forty-four balls.

The four digits are the size of the part in hundredths of an inch, two for the length and two for the width. So 0805 is 0.08 by 0.05 inches, 0603 is 0.06 by 0.03, and 0402 is 0.04 by 0.02. An inch is 25.4 millimetres, so you can turn either figure into millimetres by multiplying. The lab prints the millimetre size of whichever part you pick, so you can check the arithmetic yourself.

The name says nothing about what is inside the box. Those same sizes carry resistors and every other two ended part. Somebody saying a board is all 0402 is telling you how small the parts are, and nothing about what they do.

No, because somebody else will have soldered one already. A breakout board is a small piece of board with the awkward package fitted in the middle. Round its edge is a row of ordinary holes, 2.54 mm apart, the same spacing as the header pins along the edge of a board. The difficult joints are made by machine in a factory, and what reaches you is a part with holes big enough to push a wire into.

That is how most radio chips and most sensors get onto a home bench at all. You pay several times the price of the bare chip for the extra board and the fitting, which is a fair trade the first hundred times. The same trick puts fine pitched chips on a breadboard, the plastic block full of holes 2.54 mm apart that parts push into. Nothing else would get pads a fraction of a millimetre wide into holes that size.

Every pin has a pair of protection diodes built in behind it, one up to the supply rail and one down to ground. A diode is a one way valve for current, the same part you fitted across the motor switches in Step 8. In normal use both valves are shut. They are there to catch a stray voltage that climbs above the supply or drops below ground, and steer it away before it reaches anything delicate.

Put the part in backwards and the two rails are pushed on the wrong way round. That leaves those valves pointing the way the current wants to go, so the whole supply pours through them and through the metal threads inside the chip. Nothing is limiting it. Those threads are a fraction of the width of a hair, they heat in milliseconds, and something inside opens or melts before you have finished noticing the smell.

Almost never. The thread of metal joining a pin to the outside world is thinner than a hair, and current warms whatever it flows through. A little warmth is nothing at all. Past the absolute maximum the heat arrives faster than the chip can shed it, and something inside melts, or the material around it changes for good. No bang, no smoke, usually nothing to see.

The nasty part is the timing. Sometimes the pin is deaf the moment you switch on. Sometimes the board works for a month, and then one pin stops while the rest of the chip carries on. You spend a weekend hunting a bug in a program that was never wrong. That is why "it worked when I tried it" says nothing at all about a rating, and why this block sits near the front of the sheet.

DC is short for direct current, meaning current that flows steadily in one direction. The electricity in a wall socket does not: it goes back and forth fifty times a second, and that is AC. Everything on this board is DC. A row that also says continuous means the current may run that way for as long as you like, which is a much harder promise than surviving a flick.

Out of a pin and into a pin are both real. An LED wired from a pin down to GND lights when the pin is HIGH, and the current runs out of the pin: that is called sourcing. Wire the same LED from the 3.3 volt rail down to the pin instead. Now it lights when the pin is LOW, with the current running into the pin and away through the ground leg: that is sinking. Some chips can sink more than they can source and print two rows. This one prints a single row for both, which is why it is worded in or out.

Count the metal. Every I/O pin draws its current from the same place: one leg marked VCC, and one thread of wire from that leg into the chip. Whatever all your pins take at once passes through that single leg, and so does the current the chip uses to run itself. The same is true on the way home through GND. Those legs and the black body they are set into, are called the chip's package. The package has limits of its own. They owe nothing to how cleverly you spread the load.

So a row of modest pins can kill a chip that no one of them could. Moving a load onto more pins helps the per pin row and does nothing whatever for the total row. A gadget that has to light more lamps than the total allows lights them a few at a time and cycles round fast. An eye sees them all lit at once, which leans on the same fact about you as the dimming in Step 6.

Because the row is a promise about the chip, and everything else in the circuit is only roughly what it claims to be. A resistor sold as 220 ohms carries a tolerance, often 5 in every 100 either way. The one in your hand may really be 209 ohms. A supply called 3.3 volts may sit a little above that. The room may be warmer than the temperature printed at the top of the electrical block and a hot chip is allowed less than a cool one.

The space you leave between your design and the row is called margin. Aim exactly at a limit and the average part passes while some ordinary fraction of them fails. Those fail in somebody's house rather than on your bench. Deliberately working a part below its ratings is called derating, and using about two thirds of a limit is a common habit rather than a rule.

Something, whether you meant to or not. The clock belongs to the board, and while it runs both shift registers shift. When the board wants only the chip's answer, it sends filler, usually 0xFF or 0x00. A chip that is expecting to be read ignores whatever arrives. It works the other way too: when the board wants only to send, an answer comes back anyway, and the program throws it away.

That is why the operation has a different name here. A program talking to an SPI chip does not read or write, it transfers, because one byte out and one byte in is the smallest thing that can happen. The first lab shows both bytes moving at once. The one going out is the row of squares you can click. The one coming back is chosen from the menu underneath.

Because nobody ever settled it. SPI was described by one company and copied by everybody. No committee ever said which edge was the right one, so parts shipped with all four combinations, and all four are still on sale. A datasheet writes the two choices as CPOL and CPHA. Polarity is the level the clock rests at between bytes. Phase is whether the reading edge is the first edge of a bit or the second one.

They are two questions rather than four arbitrary numbers, which makes them easy to keep straight. Polarity is the top half of the mode number and phase is the bottom. Mode 0 is both zero. Mode 1 keeps the resting level and moves the reading edge. Mode 2 moves the resting level and keeps the edge. Mode 3 moves both. You never have to guess which one a part wants: it is printed in the datasheet, and setting it is one line in your program.

A read with no margin is a race. One side is changing the wire at the instant the other looks at it, and which value wins is decided by a few nanoseconds inside two parts that were never promised to agree. It can come out right. It can come out right every single time, on the board on your desk, with short wires, in a warm room.

Then the next board off the shelf has a slightly quicker chip on it, or the wires are longer, or the room is cold. Now it comes out wrong once an hour. A fault that shows up in one unit in ten costs far more than one that shows up in all of them, because the units that work are what stop anybody looking. The first lab will not name a winner for a read with no margin. It prints both possible bytes and says that nothing in the wiring chooses between them.

Three questions decide it: how many chips, how fast, and how many pins you can spare. I2C is two wires however many chips hang off them. It pays for that with an address and an ACK on every message, so it suits several slow parts. SPI is three shared wires plus one chip select each. It buys back the address, the ACK and the waiting, so it suits one or two fast parts, such as a screen or a memory card. UART is the third one you will meet. The second lab puts it in the table beside the other two, and Step 21 is about it.

A UART link has no clock wire at all. It is one wire each way between two devices, with both ends agreed beforehand on how fast the bits will come. That is what the cable from a board to a computer uses to carry printed messages. There is no address, because there is nobody else on the wire to address. Nothing is shared either, so a second device costs two more pins and another link inside the chip. Chips are built with only a couple of those, and that limit arrives long before you run out of pins.

The fall at the front of a character is the only event it ever gets. From that moment it counts its own bit times. It looks at the middle of each one, not at the edges. The middle is the point furthest from both edges. So the two ends can be a little out of step, and the look still lands inside the bit it belongs to.

How far out they may be follows from that. The tenth look is the last, and it comes nine and a half bit times after the fall. A small difference in speed has all nine and a half of them to pile up in. Once the pile-up passes half a bit time, that look crosses into the bit next door and the character changes. Then the next character starts the counting again from its own fall. That is why a long line is no worse than a short one: the error never gets more than ten bit times to grow in.

A chip makes a bit time by counting ticks of its own clock. Only certain lengths come out exactly right, so everyone settled long ago on the same short list of speeds. 9600 is the old safe default, and 115200 is the usual fast one. Neither number is special in itself. A bigger one holds each bit for less time. More characters fit into a second, and there is less room for the two ends to disagree.

Serial settings are usually written as the speed and then 8N1. That is eight data bits, then N for no extra check bit, then one stop bit. The check bit it is refusing is a parity bit. Some setups add one so that a single flipped bit can be spotted. Nothing here sends one, and 8N1 is what almost everything uses. Both ends have to agree on all three parts, not only the speed.

On most boards a second small chip sits next to the main one. It turns this stream of bits into USB. So the cable you already plug in to power the board is carrying it. With a bare chip you add a small adapter that does the same job. Either way, the wire in this step is the wire, with a translator on the end of it.

At the computer, a terminal program draws one character for every number that arrives. It has a speed setting of its own, and that setting is the one people forget. The board gets changed to a new speed. The program on the computer is left at the old one. The screen then fills with nonsense from a board that is working perfectly.

It does two jobs. The first is to guarantee a high before the next character, so that the next fall is a real fall. Characters follow each other with no rest. Without that guaranteed high, two in a row could run together, with no edge between them for the listener to start from.

The second job is a free check. The tenth look expects to find the wire high. If it finds it low, the ten bit times did not line up with the ten that were sent. A real chip reports that as a framing error, and many programs answer by throwing the character away. The stop bit is where a mismatched speed shows up first, because the tenth look has had longest to drift.

Because the voltage a resistor drops depends on the current through it. That is the divider from Step 10, doing exactly what it did there. A board might take 30 milliamps while it is idle and 300 with its radio on. A resistor picked to drop 1.7 volts at 30 milliamps drops ten times that at 300, and the rail would move every time the board did anything.

A regulator watches its own output instead, and adjusts thousands of times a second, so the output stays put while the current wanders. What it cannot do is invent voltage. Both kinds need their input to sit above their output by some margin. Below that margin the output simply follows the input down.

Because the heat has to go somewhere, and a part soldered flat to a board has almost nowhere to put it. A small package with no metal bolted to it warms up in proportion to the watts it is burning. Double the waste and you roughly double how far above room temperature it sits.

Past a temperature printed in its datasheet, the part turns itself off to save itself. The rail collapses and the board stops. Then the part cools and starts again. What you see is a device that works for half a minute, dies, and comes back. Nothing in the program is wrong, and reading the program will never show you that.

Cost and quiet. A linear part is a component with three legs and a capacitor at each end. A switching one needs a coil, more parts around it, and a careful board layout. It costs more. At small currents the heat a linear part makes is nothing worth avoiding.

The quiet matters when the board is measuring something. Chopping leaves a small wobble on the rail, called ripple, and the converter from Step 10 measures against that same rail. A reading taken at the wrong moment in the wobble comes back a count or two out. The lab below gives the ripple in millivolts and in converter counts, so you can see whether it would reach the number you care about.

A motor turns because current in its coils makes a magnetic field, which is the switchable magnet of Step 9. Once the rotor is moving, those coils are dragged past a magnet. That produces a voltage of their own, pushing back against the supply, and the push-back is most of what limits the current in a running motor.

A rotor that has not started yet pushes back with nothing. The only thing limiting the current is then the resistance of the winding, which is small. For a little motor that is several times the running current. It dies away over a few thousandths of a second as the rotor picks up speed. A rotor that is jammed never picks up speed, so its current never dies away at all.

Because the two supplies still share a ground wire. They have to. Two circuits with no shared ground have no agreement about what 0 volts means, which is the point made about the servo in Step 7. Every amp the motor takes comes home along that shared wire.

A wire is a resistor with a very small value, a few hundredths of an ohm for a short thick one. Current times that small resistance is a small voltage. It appears as the ground under the chip lifting while the motor pulls. The chip cannot tell that apart from its supply dropping, because it only ever sees the difference between its two pins. Short and thick is the whole of the fix, and the lab below measures what is left.

TTL is the older family, named after the way those chips are built inside. Its two numbers are fixed and they are low, and they were settled by parts made in the 1970s. Chips made today keep to them so that old and new can be wired together. That is the whole reason a 5 volt part can be perfectly happy with 3.3 volts arriving: a decision taken half a century ago.

CMOS chips set both numbers as a fraction of their own rail instead, around seven tenths for a 1 and three tenths for a 0. Move such a part onto a 3.3 volt rail and its bar for a 1 comes down with it. Leave it on 5 volts and the bar sits above anything your board can send. The two buttons in the lab load each pair and print the numbers they are loading.

Because nothing has gone near it before. Every input pin has a pair of them, one up to the rail and one down to ground. They carry no current at all while the voltage on the pin stays between the two rails, which is where a pin normally lives. They start carrying only when something pushes the pin outside that range.

Once the pin is pushed above its rail, the diode holds it a little above the rail and will not let it climb further. Everything above that has to be dropped across whatever resistance sits in the path, and that is what decides the current. Current is the thing the diode has a rating for. So the same 5 volts is survivable through a large resistor and fatal through a plain wire, where the only resistance is the sending pin's own few tens of ohms. The lab works the current out for you, and names the rating when you go past it.

A pin and the wire on it behave like a very small capacitor, the part from Step 22: two pieces of metal near each other holding a little charge. Before the voltage at the pin can change, that charge has to be moved in or out. The amount is tiny, measured in picofarads, which are millionths of a microfarad. The line above the trace in the lab says how much this model allows for a pin with a short jumper wire on it.

Resistance limits how fast charge can move, so it sets how long that filling takes. A pin driving directly has only its own few tens of ohms in the way, and the edge takes nanoseconds, thousandths of a microsecond. Put a 10 kilohm resistor in the way, a kilohm being a thousand ohms and the same edge takes hundreds of times longer. None of that matters while each level lasts a millisecond. When a level is shorter than the edge, the voltage is still on its way up when the receiver looks and the receiver reads whatever has arrived so far.

Three reasons, and the lab measures all three. A divider only works one way, from a higher rail down to a lower one, so it can never lift 1.8 volts to what a 3.3 volt CMOS input wants. It pulls current the whole time the line is high, which a battery notices. And it slows every edge, which costs nothing on a button and loses bits on a fast bus.

The transistor answers all three, and it works in both directions on the same wire. That last part is what I2C needs. The ACK tick in Step 11 was the sensor pulling SDA down, so both ends drive that one wire and a one way divider would be no use there. What has to be right when you fit one is which side is which. The deciding leg goes to the lower of the two rails and the leg marked source goes to that same lower side. The transistor drawn in the lab is marked BSS138, which is the part number most of these little boards carry. For a fast one way line, an SPI clock at several megahertz, people fit a chip made for the job instead.

One sensor tells you how dark the floor is under it, and nothing else. A reading halfway between tape and floor means the edge of the tape is under the spot. That is equally true whether the tape has slipped to the left or to the right. A robot with one sensor has to hunt: swing one way, see whether the reading got darker, swing back if it did not. It works. It wags all the way down the straights.

Two sensors give a difference, and a difference has a sign. Whichever of the two is darker is the side the tape is on. There are two ways to get a difference of zero, mind. One is dead centre. The other is both spots out on bare floor with the tape nowhere near. The difference cannot tell those apart, but the two readings can, and when both stay near zero for long enough the robot below stops and says it has lost the tape.

Because nothing in a real loop happens at the moment it is decided. The sensors sit in front of the wheels, so the robot feels a corner before the wheels reach it. The reading the program steers on was taken a few passes round the loop ago. The wheels then take a moment to settle to the new speed they have been given. Every correction arrives after the situation that asked for it.

A late correction that is small does no harm. A late correction that is large arrives once the error it was meant to cancel has gone. It carries the robot past the middle the other way, and the next one carries it back. That is the snaking you can produce in the lab below, and turning the steering up makes it worse rather than better. Measuring how late a loop is, and choosing the steering to match, is the whole of Control Systems.

Because the memory on a chip like this is a few tens of thousands of bytes, and the program's own variables live in it too. Four bytes a reading sounds like nothing until the device is meant to sit there for a year. Sooner or later every logger has to decide what to forget.

The usual choice keeps two things. First, the newest few readings, so that recent history can be looked at. Second, a handful of summaries brought up to date as each reading arrives: the biggest jump so far, a running total, the highest and the lowest. Each of those is a couple of numbers being compared and replaced, so they cost the same after ten thousand readings as after ten. What you give up is any question you did not think of in advance, because the readings that would have answered it are gone.

A filter that leans on the last few readings answers with a mixture of them. Its answer therefore describes some moment part way through that stretch, not now. While the weather is barely moving, and the wobble is the only thing changing, that is a good trade. Lean on more minutes than the weather stays still for and the filter is reporting a temperature that has already gone.

Step 16 measured that trade on a run of readings. The lab below is harder on it. The weather in there was invented by the simulation, so the widget knows the true temperature, and it holds both the raw number and the kept number against it. No real board can do that. Working out what a sensor's answer means when nobody knows the true value is calibration. It is its own subject.

A bad vector address, wrong linker script, unsupported clock setup, stack outside RAM, failed memory copy or a constructor can all fault first. Attach the debugger at reset, inspect the program counter and vector words, then step through startup. Do not keep adding prints; the serial port may not exist yet.

The processor uses addresses for both. Some ranges select RAM or flash; other ranges select peripheral registers. A write to a GPIO register changes hardware rather than storing an ordinary variable. Use the vendor header and the right access width. Reserved bits must be kept at their documented values.

The ADC’s small sampling capacitor still holds charge from the previous channel. It must settle toward the new voltage through the new source. Data sheets specify acquisition time and source impedance. A dummy conversion, slower ADC clock or buffer may be required; test across the full input range.

Optimisation changes instruction order, removes unused reads and keeps values in registers. Undefined behaviour and data races often surface here. Reproduce with the exact release flags, keep debug symbols, inspect the disassembly around the fault, and fix the invalid assumption rather than disabling optimisation.

Almost always. A handler should capture the event, clear the hardware source and wake or enqueue work. Blocking, printing, allocation and long calculations increase latency for every other interrupt and make timing hard to prove. The Real-Time Systems course develops response-time analysis and priority inversion.

A high-priority task waits for a lock held by a low-priority task, while a medium-priority task keeps pre-empting the low one. Priority inheritance can raise the lock owner long enough to release it. Better designs also keep critical sections short and avoid sharing resources across unrelated deadlines.

The MCU may sleep at a few microamps while the regulator itself draws tens or hundreds. Add every part’s quiescent current, pull-up current and leakage. A power switch for a sensor helps only if its own leakage and the sensor’s restart energy make the trade worthwhile.

It can exhaust endurance quickly and wastes energy. Save only when the application can justify the wear, batch changes, or use a journal/wear-levelled store. If exact monotonic counting matters for security, use hardware designed for it or a protocol that cannot move backwards after a reset.

Cable length, ground bonds, enclosure seams, battery leads and display windows change antennas and return paths. Test the assembled product in each operating mode. Record clock rates, radio channels, motor loads and cable arrangement so a failing emission can be reproduced.

No. It proves that an allowed signer approved the bytes and that the image meets policy. Bugs, unsafe commands and stolen signing keys remain possible. Keep signing keys offline or in a managed hardware-backed service, require review, and make revocation and recovery part of the release plan.

It should prove the same things as handwritten code: correct register sequence and reserved bits, bounded waits, bus recovery, concurrency rules, power-state transitions and known behaviour for every hardware error. A vendor reference driver is useful comparison evidence, not a substitute for the product test.