The model box that runs the show

A white card model at 1:25 is the oldest tool in this building. Wire it, and it becomes the cheapest complete show system you will ever own: a rig, a network, a control layer, an automation cue and an audience, all on a desk, where breaking it costs nothing and teaching on it costs an afternoon.

This is the project spine of the course. It is optional in the sense that you can pass without it, and it is the reason most people who take this course remember it.

What you end up with. A 1:25 model box with a lit rig, a moving element, sound, and a cue stack, driven from the same protocols a real building uses, running a two minute show that you can hand to somebody else and watch them run.

What it costs. Between HK$900 and HK$2 600 depending on how much you already own and how elaborate the moving parts get. That is one seat at a decent opera, for a system that will teach you more than any three of them.

Why a model rather than a simulator. Because in a simulator, everything works. The value of this project is entirely in the things that do not: the pixel string that browns out at the far end, the servo that hunts, the Wi-Fi that drops when the room fills, the cue that fires twice. Those are the lessons, they cost you a Saturday here, and they cost a production a preview.

What is in the box#

The point of the table. Every row is the same object at a different scale. Nothing on the left is a toy version of the thing on the right; it is the thing on the right with fewer of it. The protocol is identical, the failure modes are identical, and the arithmetic is identical.

The build, in five stages#

Each stage stands on its own. Stop after any of them and you still have something that works, which is the only sane way to schedule a build.

Stage 1 — Light it, from a program you wrote#

Parts: ESP32, a 1 m strip of WS2812B cut into booms, a 5 V 3 A supply, a 470 Ω resistor on the data line, a 1000 µF capacitor across the supply. HK$200–350.

What you do. Drive the pixels directly from a sketch. No network, no desk. Write a fade, a chase, and a state machine that responds to a button, which are exactly the three programs you built in the block workspace.

What you learn the hard way. The far end of the string is dimmer and slightly the wrong colour, because the copper in a cheap strip has resistance and you are drawing amps through it. Inject power at both ends and it stops. That is voltage drop, it is on the syllabus in Electronics for Theatre, and here you can see it.

The number to write down. 60 mA per pixel at full white. 120 pixels is 7.2 A, which is not a USB cable, and finding that out on a desk is much better than finding it out on a costume.

Stage 2 — Put it on the network, and drive it from a desk#

Parts: an unmanaged 5-port switch, two patch leads. HK$80–200.

What you do. Flash an Art-Net or sACN receiver onto the ESP32. Patch the pixels in free desk software: MagicQ, Eos Nomad or grandMA3 onPC all run on a laptop. Now your model box is being driven by a real console, over the real protocol, in a real universe.

What you learn the hard way. Static addresses, or nothing finds anything. 170 pixels is one universe, and pixel 171 is on universe 2 whether you planned for it or not. A desk sending 40 frames a second to 4 universes is a real amount of traffic on a bad switch, and it looks like a lighting fault.

The moment worth having. The first time somebody else, sitting at the desk, brings up a look on your model and does not think about how it works. That is what a working system feels like from the outside, and it is the standard.

Stage 3 — Move something#

Parts: two MG996R servos or a small stepper with a driver, a separate 6 V supply, a limit switch per axis. HK$150–400.

What you do. A truck that tracks on, or a flown piece that comes in. Driven by the ESP32, on a cue from the desk, with the limit switch as the thing that actually stops it.

What you learn the hard way, and this is the important one. The servo hunts and buzzes when it arrives, because a position command is not a movement profile. It needs an acceleration ramp, which is the fade exercise again with different units. It draws a current spike on start that browns out your pixels if they share a supply. And the limit switch is not a suggestion: the software knows about the limit, the switch enforces it.

Write the failure behaviour down before you build it. On loss of control, a moving thing stops. Not holds, not returns home: stops. That is the row from the safe states exercise and it is the row that transfers directly to a real automation conversation, where you will be the person asking about it.

Stage 4 — Give it sound, and a cue stack#

Parts: Pi Zero 2 W or a Pi 4, a small class-D amplifier, two 3 W speakers. HK$350–800. Or: nothing, and run QLab on the laptop.

What you do. The desk sends OSC when a lighting cue fires. The Pi hears it and plays a file. Now you have two departments talking, which is the entire subject of show control, and the whole thing is on a desk.

What you learn the hard way. The two events are not simultaneous, they are about 20 to 60 ms apart, and whether that is invisible or a disaster depends on what the sound is. A network hiccup delays one and not the other. If the OSC message is lost, nothing tells you, because OSC over UDP does not.

The design decision. Send state or send events? A cue is an event and it can be missed. A heartbeat carrying "we are currently in cue 12" recovers by itself. Real systems use both, for different things, and knowing which is which is the content of Show Networking and Control Systems.

Stage 5 — Make it a show, and hand it over#

Parts: none. This stage is the assessment.

What you do. A two minute show: at least six cues, one automation move, one sound cue, one deliberate failure you have designed the response to. Then a README, a one page card in the case, and somebody who has never seen it running it from cold while you sit on your hands.

What you learn. That the build was the easy half. This is the capstone standard, and Class 6 is where it is marked.

The shopping list, in one table#

Free software you will use: MagicQ, Eos Nomad or grandMA3 onPC for the desk. QLab in its free tier, or Reaper, for sound. Arduino IDE or PlatformIO. Git. Every one of these runs on a laptop and costs nothing, and between them they are most of a real control room.

Five shows to build on it#

Each is a different systems problem wearing a different costume. Pick the one that scares you slightly.

1. A storm. Pixels, sound, and a gobo wash, all built from one intensity value that ramps. Trains: one parameter driving many outputs, and why that is a better structure than six cues.
2. A revolve with a light that follows it. The position of the moving thing changes what the rig does. Trains: feedback, and the fact that your lighting now depends on your automation being honest about where it is.
3. A séance. Practicals on stage, flickering, with one that fails on purpose at a specific moment. Trains: designing a failure and making it repeatable, which is much harder than making a thing work.
4. A curtain call. Eight cues in forty seconds, called by a DSM standing behind you. Trains: the operator's experience, which is the part a builder never tests.
5. A tech rehearsal. Somebody else changes the cue list while you are running it. Trains: version control on a show file, and why Class 3 spends forty minutes on git.

The rules that come off this project#

Every one of these was learned by somebody at 1:25 before it cost them anything at 1:1.

• Power is a design, not a cable. Measure the current, inject at both ends, keep motors on their own supply.
• Static addresses, written on the device. A label maker is show equipment.
• The limit switch enforces, the software knows. Always in that order.
• Two of everything you cannot buy on a Sunday.
• The show file is in git and the git is not on the show machine.
• Every device has one page in the case: what it is, its address, its behaviour on power-up and on loss of control, its indicator codes, and a phone number.
• A thing is finished when somebody else can run it, not when it works.

They are on the working rules card, and they are worth more than any of the code.

Numbers from this page#

Where this goes next#

• The boards page is the parts and the trade-offs in more detail.
• The systems page is what the products in the same roles cost, and when to buy instead.
• Class 5 is where stages 1 to 3 are taught.
• Class 6 is where stage 5 is assessed.