From Cheap IR Remotes to Hidden Window Glow: What LEGO Strip Lights Can Really Do
Most people meet strip lights as decoration: a reel of LEDs, a small remote, and a controller. In a LEGO build, the same parts can do three more useful jobs. A remote can become a button panel. A LEGO LED strip can become a controllable output. A hidden strip can make the stained glass in a LEGO Architecture set glow. None of this needs exotic hardware. The awkward part is getting the software to recognize what is connected.
A strip light is a flexible circuit with LEDs on it. It may be a third-party strip with an IR remote, or LEGO's own Powered Up LED Light Strip, 88005. Treat it as an accessory: something you add to solve a specific problem, not a product with one fixed role.
Three Jobs for One Accessory
- Input: a cheap LED-strip remote becomes a row of physical buttons.
- Output: the 88005 becomes a light that a program can switch on and off.
- Model craft: a hidden strip makes the stained glass in 21065 Sagrada Família glow.
Each job uses the same basic idea in a different way. Light can carry a signal, deliver illumination, or change how a material reads. The interesting part is what each job demands from the software.
1. Turn A Cheap Remote into A Button Panel
Many LED strip kits include a small infrared (IR) remote. It runs on a CR2032 coin cell and sends a short burst of invisible light when you press a key. The receiver in the kit turns that burst into a command. It listens for a 38 kHz carrier, which helps it ignore steady room light and focus on the remote's pulses. A microcontroller can read the same signal, which means the remote can become a general-purpose keypad.
One test used a homemade ESP32 bridge for Power Functions infrared control (PFIR) over Bluetooth Low Energy. It was checked with Power Functions (PF) receivers and transmitters, and with generic LED strip remotes. The cheap remote worked, even with an old TSOP 38438 receiver.
The reason is a little counterintuitive. A PF handset is built for range, so it blasts a lot of IR. Up close, that can swamp the receiver and produce noise. A strip remote is much weaker. It sends just enough light to cross a room, and the receiver sees a cleaner signal. The remote also has plenty of keys, so there are many buttons to map.
To turn it into a keypad:
- Use a 38 kHz IR receiver such as the TSOP 38438 or a modern equivalent.
- Connect it to an ESP32 and log the raw code from each key.
- Map the codes to actions in your program.
- Keep the remote at a sensible distance. The low-power remote is more forgiving than a PF handset.
- Treat the remote as a button panel, not as a light controller.
The strip itself is not being controlled. The remote is simply a source of button presses. That is the useful lesson: input does not always need a new sensor or a phone app. A cheap remote you already own can become the human interface for a model.
The limits are just as important. Blockly has no native "generic strip remote" device, and there is no standard code table for every remote. You need a receiver, a microcontroller, and a way to pass the decoded keys into the program. The hardware is easy; the software bridge is the missing piece.
2. Use The 88005 as A Real Output
The second job is the opposite. Instead of reading a signal, the model sends power to a light. The device here is the LEGO Powered Up LED Light Strip, 88005, usually called the "PUp LED" or simply "the light."
The setup is a two-port PUp hub, 88009, with a Technic L motor on one port and the 88005 on the other. The motor drives the model; the light is meant to be a controllable output. That sounds simple, but the software has to answer a basic question first: what is plugged into the port?
A PUp device identifies itself with a number called an ioType. Think of it as a name tag. The hub reads the tag and passes it to the software. If Blockly has a definition for that number, it knows what the device is. If not, it shows an unknown device.
Here, the motor reports ioType 46. The light reports ioType 8. Blockly does not have a built-in definition for the 88005, so it initially sees an unknown light. It then generates a profile for that unknown device, maps it to the port, and keeps going. The port map is simple: A is 0, B is 1.
The code is easy to misread. ioType 8 could look like a fallback value for an empty port, but a device list used in the test settles the question. 8 (0x08) is the 88005; 50 is the hub RGB LED; 23 is the remote RGB LED; 2 is the PUp train motor; and 64 (0x40) is the SPIKE 3x3 Color Light Matrix. The strip has a real ID; the software simply did not ship with a definition for it.
There is also a quick way to tell how the system sees the light. When the PUp LED is controlled from a PUp remote's plus and minus keys, its output changes in steps. A smart motor behaves differently and jumps to full forward or reverse. The light is being treated as a simple load, not as a motor with feedback.
The practical workaround is to control the light with a motor block. A motor block sends power to the port, and an LED strip only needs power, so the block can switch it on and off. In the locomotive setup, the green button on the PUp remote controls the light while the right-hand B dial stays reserved for manual driving. The same approach scales to an FP7 or F7, where the green button toggles the head and cabin light.
It works, but it is still a workaround. The block was designed for a motor, not a light. There is no native brightness control, no color control, and the strip in this example is white. A dedicated light block would solve that, but it does not exist yet.
To repeat the setup:
- Connect the 88005 to a hub port and connect the hub to Blockly.
- Open the console and look for
ioType 8and the generated light profile. - Let Blockly cache or paste the profile, then confirm the port map.
- Use a motor block as a temporary switch.
- Map a remote button to the block and document the port, profile, and button assignment.
- Do not expect dimming, color, or effects from the stock block set.
The lesson here is that recognition and control are two different problems. The hub can detect the 88005 before the programming environment knows what to do with it. A device ID is not the same thing as a useful set of controls.
3. Light The Stained Glass
The third job is visual. LEGO 21065 Sagrada Família is an official Architecture set with 12,060 pieces and a finished model about 62 cm tall. Its nave is built around branching columns that rise and split like trees. The stained glass is represented by transparent plates: cool blues and greens on the Nativity side, and reds, oranges, and gold on the Passion side.
The plates are not self-luminous. In ordinary room light they read as colored surfaces. When ZENE Bricks light passes through them, the color spills onto the columns and floor. That is where a hidden strip earns its place. Place a neutral-white strip behind the transparent plates, inside the nave, and the plates become the light source. The color comes from the plastic, not from the LEDs.
A colored strip is usually the wrong choice here. The set already supplies blue, green, red, orange, and gold; adding another hue can muddy them. A neutral white strip lets the plates do the color work. Diffusion matters too. A bare LED can create a bright spot on one plate while leaving its neighbor dark. A diffused strip spreads the light more evenly, so the stained glass reads as a window rather than a row of colored tiles.
The set is designed as a display model, not a light-up kit. It gives you the architecture and the transparent color; a strip supplies the missing light. The exact placement, power source, and wiring are left to the installation.
The value is in the combination. Without light, the stained glass is a colored detail. With light, it becomes part of the atmosphere. A hidden strip can make the nave read as a lit interior without adding a visible fixture.
If you want to repeat the effect, the details matter:
- Plan the cavity before the shell is closed. In a large set, removable facade sections can provide access.
- Put the strip behind the transparent plates, not in front of them. The plates should color the light, not reflect the source.
- Use neutral white. The plates already provide the color.
- Diffuse the strip so individual LEDs do not show through the plates.
- Test in a dark room for leaks at seams and roof joints.
- Plan access for batteries, wiring, and repairs.
- Keep heat and cable routing in mind. Do not trap a strip against plastic.
The lesson is that a strip light is not only a light source. It is a way to change how a material reads. In 21065, the transparent plates are the stained glass; the strip is what makes them behave like glass.
Why Lights Are Still Hard to Program
At this point, the word "light" has done a lot of work. In Blockly, it can mean several different things:
- The 88005 white LED strip.
- The RGB status LED on a hub.
- The RGB LED on a PUp remote.
- A single LED used as a VLL optical emitter.
- A 9V bulb or a fiber-optic element on an old Interface A or B.
- A 3x3 LED matrix on a SPIKE hub.
Those devices are not interchangeable. A status LED needs a color and a blink pattern. A VLL emitter needs precise timing. A strip needs brightness, possibly color, and often a fade or effect. A matrix needs pixel-level control. Treating all of them as "a light" is convenient for a first pass, but it hides what each device can actually do.
VLL is a common source of confusion. It means Visual Light Link, and although it uses an LED, it is a communication protocol, not illumination. VLL uses a single LED and a resistor, or an old RCX tower, to send optical commands to a Code Pilot or MicroScout. It solves a different problem: how to talk to vintage smart bricks with light pulses. It says little about how to light a model or dim a strip.
The same caution applies to RGB. Hub RGB LEDs and the SPIKE 3x3 Color Light Matrix are indicators and displays, not strip lights. The Sagrada Família case gets its color from transparent plastic, not from an addressable strip. The 88005 in these examples is white. Color-changing pixels and lighting effects are simply not part of what the hardware demonstrates here.
So the gap is not power. It is description. A program needs to know whether a light is a switch, a dimmer, a color display, or a signal emitter. Right now, many of those devices are forced into a generic "light" or "motor" box, and the details are lost.
Four Things Worth Building Next
These are practical next steps, not product promises. Each one turns an improvised result into something easier to repeat.
1. A clear 88005 guide
The 88005 workaround is technically sound but hard to discover. The knowledge is spread across console logs and one-off tests. A good guide would walk through the whole sequence: connect the strip, open the console, identify ioType 8, generate or accept the profile, confirm the port map, and use a motor block as a temporary switch.
It should also cover the questions people actually ask. What does an unknown device mean? What happens if the profile is not cached? How do you tell a light from an empty port? How do you map a remote button without losing motor control? And it should be honest about the limits: no native dimming, no color, no effects, and no guarantee that one profile fits every firmware version.
You will know the guide works when a boxed 88005 can become a working on/off light without guessing which device type to choose.
2. A repeatable IR-remote recipe
The cheap strip remote is already proven. What is missing is a documented path from an arbitrary remote to usable button events.
That recipe would include a recommended receiver, a wiring diagram for the ESP32, a sketch that logs raw IR codes, a table for mapping each key, and a way to expose those keys to Blockly. It would also cover the practical limits: range, angle, battery condition, and the risk of saturating the receiver with a stronger remote. The goal is not to control the strip. The goal is to turn the remote into a generic input panel.
You will know it works when a random LED strip remote can be decoded in a few minutes and four or five of its keys assigned to actions.
3. A stained-glass lighting playbook
The Sagrada Família set shows the visual payoff of a hidden light source, but it is not a ready-made installation. A playbook would cover cavity design, strip placement, diffusion, neutral-white output, light leaks, wiring, battery access, and heat.
The playbook would also explain the color decision. In 21065, the color is already in the transparent plates: blue and green on the Nativity side, red, orange, and gold on the Passion side. If the strip is also colored, two color filters stack: the LED adds its own hue before the plate filters it again. That can push blues toward green, flatten reds, or make the whole nave look muddy. A neutral-white strip avoids that problem. It gives the plates a clean light source, so the color you see is the color built into the model.
A bare LED is another common mistake. It is a small, intense point source. Behind a transparent plate, it can produce a bright dot, a visible hotspot, or a hard-edged pool of light on the floor. A diffuser spreads the light before it reaches the plate, so several LEDs read as one soft glow. Frosted plastic, a sheet of translucent material, or simply more distance between the strip and the plate can all help. The goal is even illumination, not maximum brightness.
Testing should happen before the model is closed. Build the nave or the relevant facade section, connect the strip temporarily, and turn off the room lights. Look for three things: whether the plates glow evenly, whether light leaks through seams or roof joints, and whether the strip itself is visible from the front. Move the strip a few centimeters and test again. Small changes in distance often matter more than a brighter strip. Once the effect looks right in the dark, check it again in normal room light; it should still read as a lit interior, not as a lamp hidden inside a model.
You will know the playbook works when lighting is planned at the same time as the interior, rather than added after the shell is closed.
4. A proper light type in software
The last step is the most important. Blockly needs a better model of what a light is.
At minimum, that model should distinguish a light from a motor, expose on/off, and allow brightness where the hardware supports it. It should also carry a device identity, so an 88005 can be told apart from a hub RGB LED or a VLL emitter. For addressable strips, it should leave room for color and effects. For third-party strips, it should make the protocol boundary explicit instead of hiding it behind a motor block.
A compatibility map is the first step. It would list device IDs, ports, capabilities, and known workarounds for every light type covered earlier. That would save new users from rediscovering the same console messages and give the software a clearer target.
You will know the model works when a light can be described by what it can do: switchable, dimmable, colored, or timed.
What to Remember
Strip lights are useful because they let a model do something ordinary bricks cannot. The three examples show three different jobs: a cheap strip remote becomes a button panel, an 88005 becomes a light the software can switch, and a hidden strip turns the Sagrada Família's transparent plates into stained glass.
Each job asks for something different. The remote needs decoding. The 88005 needs device recognition and on/off control. The stained glass needs a neutral, diffused light placed behind the plates, not a visible fixture in front of them.
The hardware is ready. What is missing is the language to describe it. A light is not just a motor with a lamp attached, even if a motor block can switch it on. That is the real starting point for making strip lighting feel native instead of improvised.







