Where you are. You have parts, or you have decided how to get them. This lesson is the build: not screw by screw, which the official videos already do better than prose can, but the order the build has to happen in and the four places it goes wrong.
Sunday, half past four
The arm is finished. It looks right. Both halves of the shoulder line up, nothing rattles, every cable is tucked. You clamp it to the desk, plug it in, and run the first command.
The software reports six motors and they all answer to the same name.
The fix is ninety seconds per motor. Getting to each motor is twenty minutes with a screwdriver, because the one you need first is at the bottom of the stack with five others bolted on top of it.
Nothing broke. Nothing you did was wrong at the moment you did it. The build simply had an order, and the order was not printed on any of the parts.
The idea in one paragraph
Mechanically, this build is not hard. The SO-101 exists partly because the SO-100 was fiddlier: the wiring is improved, assembly is easier, and the step where you had to pull a gear out of a motor is gone. The official videos take you joint by joint and they are the authority on which screw goes where. What no video can enforce is sequencing, because a video only shows you the step you are on. So think of the build as four gates instead of a sequence of screws: the printer prints to size, each motor knows its own name, each part goes on in the orientation the video shows, and each cable has slack where the joint turns. Every gate is cheap to pass in the right order and expensive to revisit in the wrong one, and the cost of skipping one does not appear until several steps later.
Wider than the screen; scroll it sideways.
Gate one: the printer prints to size
Every motor sits in a printed cradle sized to it. A cradle a few tenths of a millimetre tight does not accept the motor. A cradle a few tenths loose lets the motor rock, which shows up much later as a joint that reads one angle and sits at another.
So the repository ships gauges, and printing them first is the whole gate.
Wider than the screen; scroll it sideways.
Gauge_0.STL and Gauge_tight_1.STL are tested against an actual STS3215. If your motors have not arrived yet, Lego_Size_Test_02_zero.STL and its minuspoint1 twin test against a 4 by 2 Lego brick instead, which is a surprisingly good dimensional reference, because Lego dimensions are consistent everywhere.
The settings that go with the gauges are the ones from the previous lesson: PLA+, 15% infill, 0.4 mm nozzle at 0.2 mm layers or 0.6 mm at 0.4 mm, supports on with slopes over 45 degrees ignored, and no supports inside horizontal screw holes. That last one sounds like a detail and is not: support material inside a screw hole is a great deal harder to remove than it is to avoid.
Gate two: identity before burial
Each of the six motors in an arm has a number, and that number is how every piece of software from here to the end of the module addresses it. A brand new motor does not have its number yet. All of them ship with the same one.
Setting a motor’s number takes seconds, and it happens with the motor connected on its own. The next lesson is entirely about why, and about the command that does it. What belongs here is the consequence for the build:
The configuration order also runs opposite to how you might guess. The gripper motor is set first and the shoulder motor last, counting down from the far end of the arm toward the base. The order is fixed in the tool rather than a matter of taste, and the reason is that the chain assembles itself behind you: when you finish with a motor you unplug its cable at the board and leave it attached to the motor, where it already belongs. The next lesson gives the command and the source line.
Gate three: orientation is not cosmetic
The videos show a specific orientation for every part, and it is worth knowing why before you decide any of it looks arbitrary. The reason below is mechanism rather than a line quoted from the repository, but it is what the orientation is protecting. The motor’s encoder measures absolute angle over one turn and reports it as a count from 0 to 4095. The joint’s usable travel is whatever part of that span the mechanism can actually sweep. Bolt a link on 180 degrees away from where the video shows and the joint still works, still reads angles, and simply has its useful range in the wrong place, so it runs out of travel on one side and never gets near the other end.
You will meet the consequence directly in the calibration lesson, where the procedure asks you to move the arm to the middle of its range before it records anything. The middle of the range is a physical fact you set with a screwdriver here.
Gate four: slack where the joint turns
The six motors share one cable chain that runs from the control board through every motor in turn. That chain crosses joints, and joints rotate.
Wider than the screen; scroll it sideways.
A cable routed tight looks tidier and is worse. When the joint rotates toward the end of its travel, the shortest path between the two connectors gets longer, and the only thing available to absorb that is the connector itself. Three-pin servo connectors are friction fits with no latch. They do not tear dramatically; they back out a fraction of a millimetre and then intermittently stop conducting, which surfaces as a motor that vanishes from the bus sometimes.
Leave a gentle loop of slack at each joint, route it on the inside of the rotation rather than the outside, and once the arm is built, sweep every joint through its full travel by hand with the power off and watch the cables while you do it.
Before you tighten the last screw
Two things that are easier now than later.
Clamp it down. The parts list includes four table clamps, and that is not packaging generosity. An arm that is not fixed to the table can move the table instead of moving itself, and an arm that shifts between recording and evaluation quietly invalidates a dataset. Clamp both arms, and clamp them where the power lead is within reach of your hand, for reasons the safety lesson makes uncomfortable.
Keep the leftovers sorted. Spare screws and the offcuts of printed support material are worth a labelled bag. The first repair you do will be a stripped screw or a cracked bracket, and both are much less annoying when the replacement is already on the shelf.
Without hardware
There is no build, and the transferable content is the ordering constraint rather than the screws.
- Instead of assembling, treat the MJCF from Module 2 as an arm somebody else already assembled correctly. Its joint limits are the mechanical gates, already passed.
- Measure this: of the four failure modes in this lesson, how many have any analogue in a model file. The answer is none, because a model file cannot be built in the wrong order.
- Read the section on gates anyway. The habit it teaches - find the irreversible step and put a check in front of it - is what freezing a dataset is doing later in software.
Check yourself
1. Why print two small gauges before printing an arm, when the arm files print perfectly well without them?
Because the arm is one large print per side and the failure is dimensional rather than visible. Every motor sits in a cradle sized to it: a few tenths of a millimetre tight and the motor will not go in, a few tenths loose and it rocks in place, which later reads as a joint whose reported angle and actual angle disagree. A gauge costs a few minutes of printing and tells you whether your printer holds the tolerance. Skipping it means the first thing that tests your printer is the finished arm.
2. A motor must be configured before it is installed. What makes that ordering constraint so easy to miss?
Nothing enforces it and nothing signals it. The parts do not carry it, the assembly videos show one step at a time so they cannot show sequencing, and a build done in the wrong order goes together perfectly and looks finished. The consequence appears only at first power-up, when every motor answers to the same name and the one you need to fix first is at the bottom of the stack under five others.
3. Your printed parts accept a 4 by 2 Lego brick correctly, but a real motor is tight in its cradle. Which measurement do you trust?
The motor. The Lego test exists so you can check dimensional accuracy before your motors arrive; it is a proxy, and it happens to be a good one because Lego dimensions are famously consistent. The motor is the actual part the cradle has to hold. Passing the proxy and failing the real thing means your printer is close but not close enough on this feature, so adjust and reprint the gauge rather than forcing the motor in, which cracks cradles.
4. The documentation asks you to check your cabling before every press of Enter during motor setup. What failure is that tip about?
Connectors that come loose while you handle the hardware, the control board’s power lead most of all. The three-pin servo connectors are friction fits without latches, and you are physically moving motors and boards around while running the procedure. A cable that backs out a fraction of a millimetre does not fail cleanly: the device stops answering, and the software reports a timeout, which reads like a software problem and is not.
5. Rank the four gates by what skipping each one costs you.
Cable slack is cheapest: reroute a cable, minutes. Orientation is next: undo one joint and reseat a horn, tens of minutes, unless you only discover it during calibration when the range comes out lopsided. Motor identity is expensive: partial disassembly of everything built on top of the motor you need. Printed-part accuracy is the worst, because it is caught after both arms have printed and the fix is reprinting them. Notice that the cost ranking is exactly the order the gates run in, which is not a coincidence; it is why they are in that order.
Do this
This is a procedure, not a program. Work through it with your own hardware and keep a written record, because the record is what you will read when something is wrong three lessons from now.
1. Generate a build sheet.
cd module-04-hardware/code
python build_sheet.py --robot-id my_follower --output build-sheet.mdIt writes a checklist with a row per motor and a slot for the ports, identifiers and gauge results you will need later. Print it or keep it open. It runs anywhere; nothing in it touches hardware.
2. Pass gate one. Print Gauge_0.STL and Gauge_tight_1.STL, or the Lego gauges if your motors have not arrived. Test the fit. Write the result on the build sheet, including which slicer settings you changed. If it fails, change one setting at a time and reprint the gauge, not the arm.
3. Print the arms. One file per arm, in the variant matching your bed size. Clean out the supports, and check that no support material is left in any screw hole.
4. Stop at gate two. Do not install a motor yet. The next lesson sets motor identities and gives you the command; come back here afterwards with six configured motors per arm.
5. Build, following the videos, one joint at a time. After each joint: check the horn orientation against the video, leave slack in the cable, and sweep the joint by hand through its travel while watching the cable.
6. Clamp both arms to the table, positioned so the follower’s power lead is within reach of your non-dominant hand.
7. Sweep everything by hand with the power off. Every joint, full travel, watching cables. Anything that snags or tugs a connector is fixed now, while it is one joint deep instead of five.
What you can now do
You can run this build as four ordered gates rather than a list of screws: prove the printer holds tolerance before committing a whole arm to it, give every motor its identity before it disappears under the next joint, understand why the orientation in the videos is load-bearing rather than cosmetic, and leave cables enough slack that a rotating joint cannot slowly unplug your robot. You also know which mistakes cost minutes and which cost an afternoon, which is what lets you decide how carefully to work at each step.