Matrix Featured Article

Matrix is the writing community of SSPAI. We advocate sharing genuine product experiences, practical knowledge, and meaningful reflections. We regularly select high-quality Matrix articles to showcase the most authentic user perspectives.

The content represents the author’s personal views. SSPAI has only made minor adjustments to the title and formatting.

---

Introduction to Bambu Lab CyberBrick & Why This Project Exists

First of all, Bambu Lab is a consumer-grade 3D-printer manufacturer whose printers—especially the A1 series—have received widespread praise. The A1 series even sells for around just ¥1,000.

Meanwhile, Bambu Lab operates MakerWorld, a large-scale model-sharing platform where beginners (those with zero modeling experience) can download community-made 3D designs and print them directly.

However, most 3D-printed objects are static—meant only for display or simple hand-manipulation. If you want your 3D-printed car to actually move, you need experience in electronics and circuitry. To address this, Bambu Lab released the CyberBrick kit, enabling beginners to create a remote-controlled 3D-printed car using simple, LEGO-like building blocks—adding a whole new layer of fun.

Here’s the official CyberBrick introduction from Bambu Lab:

CyberBrick is a modular smart-toy ecosystem that integrates programmable hardware, 3D-printed structures, and a dual-layer coding environment. It combines 3D printing with electronics and programming through LEGO-like simplicity. CyberBrick allows anyone to build and enjoy a wide range of 3D-printed creations—from RC toys to productivity tools.

However, the CyberBrick kit is not cheap. A starter set costs ¥199, and each set can only drive one toy car. That’s why I started this project: replicating “Bambu Lab CyberBrick” using inexpensive components—not only reducing cost but also unlocking more possibilities.

I call this project OpenCyberBrick. Let’s begin.

Disassembly & Replication Strategy

The Core Logic of CyberBrick

Back during the CyberBrick crowdfunding phase, I already had a rough understanding of its structure and logic through introductions and demo videos. On the day the CyberBrick kit officially launched, I bought the starter set and printed the official truck model to test it.

Although CyberBrick divides its system into a controller and a receiver, both sides use the same ESP32-C3 mini as the main control board—and they’re interchangeable. The controller side gathers input from joysticks, buttons, switches, etc., through a “remote-control baseboard” and sends that data to the receiver. The receiver side takes the incoming signals and, using its own “remote-control baseboard,” drives motors, servos, LEDs, and other output devices. Communication between the controller and the receiver appears to use ESP-NOW, a proprietary ESP protocol.

Replication Approach

Once we understand the core logic of CyberBrick, the replication strategy becomes clear.

• Main Control Board Communication Protocol: For the main control board, we also use Espressif’s ESP-series chips. The ESP8266, ESP32, and ESP32-C3 are all inexpensive and come with built-in Wi-Fi modules. Communication between modules can be handled through ESP-NOW, which conveniently solves the issue of transmitting control signals.
• Controlled Unit: The controlled unit uses an ESP8266 connected to an L298N motor-driver module (for driving the motors), a 9g servo (for steering), and a WS2812 LED strip (for headlights, turn signals, and lighting effects).
• Remote Control Unit: The remote unit uses an ESP32-C3 connected to two PS2 joystick modules (each with two built-in buttons), plus two additional button modules, forming a 12-channel controller capable of supporting a large number of actions.
• During later optimization, I realized that using a smartphone as the controller is actually more suitable. It supports more actions while eliminating the hardware and software cost of building a separate remote controller. Therefore, in the following sections, the remote-control replication will only be introduced briefly.

Detailed Look at the Controlled Side

3D-Printed Jeep Body

First, just like with CyberBrick, we need to 3D-print the Jeep parts and assemble them. But one thing to note: since we’re using loose components with much lower integration than CyberBrick’s custom modules, they take up significantly more space. Therefore, choose a larger model—small bodies won’t have enough room for the electronics.

I chose Willy’s CyberBrick RC Jeep for this project. The front trunk of this Jeep provides enough space to house the electronic components, and its structure is quite typical: a motor is used to drive forward and backward, a servo handles steering, and there are reserved slots for LED lights.

Jeep Electronics Layout

Above is the wiring diagram for the Jeep’s electronics. Here are the pitfalls I ran into:

• Different modules require different operating voltages. For example, the ESP8266 needs a stable 3.7V supply, the servo and LEDs require 5V, and the motor-driver module works within a voltage range (the higher the voltage, the stronger the torque). If you want the entire system to run from a single battery, you must add buck/voltage-regulation modules before each device.
• 7.4V batteries are relatively expensive and require dedicated chargers. But 3.7V 18650 and 14500 cells can be found in many discarded toys and electronics. I made a series-connection wire to combine two 3.7V cells into a 7.4V pack—just make sure the cells have matching internal resistance when you use them in series.
• The ESP8266’s GPIO pins connect to the signal interfaces of the motor driver, servo, and LED modules, and output PWM signals for control. However, the ESP also needs to share a common ground with all these devices.

Software Program

ESP devices support Micropython and Arduino. Since I have some Python experience, I chose Micropython for development.

The software portion of the project is already uploaded to GitHub: OpenCyberBrick GitHub / OpenCyberBrick Gitee.

Here is what each file does:

• jeep_motor.py — Motor driver program. Controls motor direction and speed to achieve forward/reverse movement.
• jeep_servo.py — Servo driver program. Controls servo angles for steering.
• jeep_led.py — LED driver program. Controls two WS2812 LEDs, enabling headlights, reverse lights, turn signals, and light-show effects.
• wifi.py — Connects the controller to Wi-Fi for LAN-based control.
• wificonfig.json — Stores network information and can be edited through the remote webpage.
• jeep_action.py — The action dispatcher for the Jeep. It converts received remote-control signals into motor, servo, and LED commands. GPIO pin assignments are also configured here.
• jeep_espnow_rec.py — ESP-NOW listener. Continuously receives ESP-NOW packets and forwards them to jeep_action.
• jeep_websocket_rec.py — Runs a WebSocket server, receives commands from a LAN webpage, and forwards them to jeep_action.
• main.py — Main program entry, used to select which control-signal source to listen to.
• jeep_remote_index.html — The H5 remote-control page, supporting both button and gyroscope-based motion control. This file is not uploaded to the ESP—save it on the phone used as the controller.

Remote Control Module Overview

Unlike CyberBrick, this project ultimately works best with a smartphone controller, even though I also implemented a standalone hardware remote. When using the phone, you can switch between button control and motion-sensor control.

ESP-NOW Remote Control

ESP-NOW control can actually be treated as an independent project—it can control not only CyberBrick replicas but any ESP-based device. It consists of both hardware and software components:

The hardware portion consists of an ESP32 connected to two PS2 joysticks, two regular buttons, a power supply, and a switch. The software portion, also written in Micropython, retrieves data from the PS2 joysticks and buttons, formats it, and forwards it to the controlled device. This remote can even switch between different controlled devices via buttons, allowing a single controller to operate multiple units.

This remote-control project may be introduced in a separate article later.

Mobile Webpage Button Control

Using a dedicated remote and a separate controlled device is still fairly costly. So why not use something everyone already owns—a smartphone—as the controller? The answer is of course yes. ESP devices have Wi-Fi capabilities, meaning they can connect to your home network via a router or create their own hotspot to form a local network.

On the controlled device’s ESP controller, a server runs in the background to receive command requests from other devices on the network and translate those commands into actions for the Jeep.

On the controller side, you can open an HTML page on your phone; button presses and releases on that page are sent to the server, enabling remote operation. There are a few special considerations:

• Since ESP devices have extremely limited memory, the server cannot return HTML content. Therefore, the control-page HTML file must be saved on the phone beforehand. On iPhone, you can open local HTML files using HTML Viewer. On Android, you can tap the HTML file and open it in a browser.
• Because real-time responsiveness is critical for a remote controller, ordinary HTTP GET/POST requests would put heavy load on the server. Instead, the system uses WebSocket long-connections, which maintain real-time performance while greatly reducing server load.

Mobile Gyroscope Control

Button-based control is simple and intuitive, but it’s not quite “cool” enough. Gyroscope control, on the other hand, is cool. On the HTML page, the phone’s gyroscope data is captured, and changes in the phone’s orientation are translated into actions for the Jeep. For example:

• X-axis:
  Tilt less than –20° → move forward
  Tilt greater than 20° → move backward
  Between –20° and 20° → stay still
• Y-axis:
  Tilt less than –20° → turn left
  Tilt greater than 20° → turn right
  Between –20° and 20° → stay still
• Z-axis: not used.
• The X and Y axes can be read simultaneously, allowing combined movements such as forward-left, forward-right, backward-left, and backward-right.

Cost Calculation

If the smartphone is used as the remote control, the entire system only includes the Jeep’s on-board electronics. Here’s a rough breakdown of the cost:

• ESP8266 or ESP32 controller: 11.7 RMB
• One L298N motor driver: 7.42 RMB (you can definitely find cheaper alternatives; I just used what I had)
• Two N20 motors: 6.16 RMB (30.8 RMB for 10 pieces)
• One 9g plastic servo: 4.7 RMB
• Two WS2812 LEDs: 0.37 RMB (11 RMB for 60 pieces)
• Two DC-DC voltage regulators: 3.6 RMB (1.8 RMB each). If you’re knowledgeable about capacitors, a cheap capacitor may suffice.
• Two 3.7V 14500 batteries: 0 RMB — you can salvage them from old toys or electronics.
• Wires, terminals, and a switch: about 2 RMB.

Total: 35.95 RMB.
This does not include some mechanical components required by the Jeep model, such as screws and bearings.

More Possibilities

Most of the functionality above is designed to match CyberBrick’s capabilities, though implemented differently on the remote side. But in fact, we have far more room to expand: adding a screen to the ESP-NOW controller, adding a screen to the Jeep, adding sound effects, adding an obstacle-avoidance sensor, and so on. This is where the OpenCyberBrick project can offer greater flexibility and fun.

Conclusion

This article only introduces the general logic of the project. There are many more hardware and software details not covered here due to space constraints. If you’re interested in this project, feel free to leave me a message — I’d be happy to discuss it.

If you know how to design PCBs on JLCPCB and you’re interested in my projects, I very much welcome you to contact me. Let’s build something fun together.