Stationery Unit D2

Greetings everyone, and welcome back!

Here's something from beyond Stationery Unit D2, an R2-D2-inspired, interactive desk organizer and pen holder.

This isn't just a 3D-printed, R2-D2-looking pen holder; it’s an interactive, web-connected desk terminal powered by an ESP32-P4 dev board.

What really brings this droid to life is its behavior. I set up a background task in the code so the device generates life-like actions all on its own. Every 20 seconds, it plays a unique sequence of astromech beeps and chirps. It uses math to pick random frequencies, so it sounds like the droid is actually thinking or muttering to itself, making it feel truly alive.

I also wanted to make it easy to use, so I added two physical buttons on top. One button (GPIO 48) triggers fun "Easter Egg" songs I coded in, like the Star Wars theme and a few others, while the second button (GPIO 47) lets me instantly toggle the screen between a Radar UI and my favorite GIFs.

The web interface is where the real fun happens. Through the app, we can play GIFs on the ESP32-P4's display, trigger a cinematic Star Wars-style quote display, or even use the text-to-astromech converter to make the droid speak any message.

The design of this project was heavily inspired by R2-D2. Instead of creating a standard cylindrical R2-D2, I went with a flatter design that incorporates key visual elements from the original droid. The body was 3D-printed and then assembled.

This article covers the complete build process, from design and wiring to setting up the code and final assembly.

Let's get started.

These were the materials used in this project—

1. Custom PCBs (Provided by PCBWAY)
2. Wavshare ESP32 P4 Dev Board with Touch Display
3. Lithium Cell for Power source 3.7V 500mAh
4. 3D printed parts
5. 4x4 Push Buttons
6. Connecting Wires
7. Speaker
8. M2 screws

The entire model was designed in Fusion 360. While this project is heavily inspired by R2-D2, I didn't follow the original design entirely; I completely ditched the traditional cylindrical body in favor of a flat, modern aesthetic that still closely resembles the iconic droid.

For the internals, I incorporated a Waveshare ESP32-P4 development board, which features a 4.7-inch display positioned slightly off-center. My idea is to print a blue screen on the display with a red circle that resembles R2D2.

To capture that authentic droid aesthetic, I modeled greeble parts, which I’ll be printing in blue, and the body will be printed in white.

On the back, I added a custom lid section that serves as a pen holder, keeping the device practical while looking the part.

The enclosure of our design comprises two main parts: the front enclosure, which is designed to resemble R2-D2, and the back enclosure, which serves as a lid for the model while also incorporating the pen holder section.

Both the front and back enclosures are secured together using M2 screws.

For adding controls, I incorporated two buttons into the design. The buttons are positioned on the top face of the model.

To mount them, I designed two retaining ribs that allow the switch PCB to slide into position securely. Before installing the switch PCB, two identical switch actuators are placed in their respective positions.

Once the switch PCB is inserted, the actuators are locked in place. Pressing these actuators activates the switches, registering the button press.

For the power source, I used a 3.7 V 500 mAh lithium-ion cell (size 14500), which is smaller than the more commonly used 18650 cell.

I positioned the battery on the opposite side of the display and added two ribs to keep it securely locked in place.

The ESP32-P4 Dev Board is placed slightly off-center. To keep it securely in position, I added several ribs that ensure the display does not move from its intended location.

To make this device look and feel like a droid, I designed several greeble parts that would be printed in Blue PLA and then placed in position.

These include a part that sits between the screen and the head section, as well as a long part that sits next to the display.

Two additional parts are mounted on the top section slightly above the display, along with a circular grille part, all of which are printed in Blue PLA.

After finalizing the model, all parts were exported as mesh files and then 3D printed on my Anycubic Kobra S1 printer using two filament colors.

Blue Hyper PLA was used for the majority of the parts, including the back enclosure, greeble parts, and switch actuator.

White Hyper PLA was used for the front enclosure. All parts were printed with a 0.4 mm nozzle, 0.2 mm layer height, 25% infill, and no supports were required for the blue parts.

Only the front enclosure required supports, as it was printed upside down, so the inner parts of the model needed support.

This is the Switch PCB we used in this project, and it's a simple one. Here, we have added two 4×4mm push buttons on a 20×20mm board. The placement of each button and the mounting holes are all positioned according to the 3D model.

A CON5 connector is also added. The first pin is connected to GND, and the remaining four terminals are connected to each button pin. Through this connector, we will later pair the UNIHIKER M10 with our button board.

BTW, we are reusing this PCB from a previous project, which you can check out at the link below.

https://www.instructables.com/HitPad/

The Switchboard PCB was provided by PCBWay. I designed the PCB in my PCB design software and sent the Gerber files to PCBWay for fabrication. The PCBs arrived within a week, and the overall quality was amazing.

Over the past 12 years, PCBWay has built a strong reputation for providing reliable PCB manufacturing and assembly services, becoming a go-to choice for engineers and makers worldwide.

This month, PCBWay is celebrating its 12th Anniversary with a special campaign. As part of the celebration, the campaign highlights the journey of makers on the platform, including how long they’ve been part of the PCBWay community and the different PCB colors they’ve explored over the years. PCBWay offers a wide variety of PCB colors beyond the classic green, including yellow, blue, red, and many more, giving makers even more ways to make their projects stand out.

The anniversary campaign also features special activities, rewards, and offers, so it’s worth checking out if you’re planning your next PCB project.

PCBWay also offers CNC machining and 3D printing services, making it a convenient platform for bringing all kinds of hardware projects to life.

1. Button board assembly was pretty straightforward. We start by placing all switches in their position.
2. Next, we flipped the board over and then used a soldering iron to solder all the leads of the push buttons.

The switch PCB is now assembled.

Here's the star of our project: the Waveshare ESP32-P4 Development Board. It is built around the ESP32-P4 microcontroller, featuring a dual-core 400 MHz RISC-V processor for high-performance applications, along with a dedicated low-power RISC-V core for efficient background tasks.

The board comes equipped with a 4.3-inch IPS capacitive touch display with a resolution of 480 × 800 pixels, providing a responsive and vibrant user interface. It supports a rich set of human-machine interaction peripherals, including a MIPI-CSI camera interface with an integrated Image Signal Processor (ISP) for image capture and processing applications. The board also features USB 2.0 OTG High-Speed (HS) support, enabling fast data transfer and versatile USB connectivity options.

For hardware expansion, it includes an onboard 40-pin GPIO header that is compatible with selected Raspberry Pi HAT expansion boards, making it easy to integrate additional sensors, modules, and peripherals.

An additional highlight of this development board is the onboard ESP32-C6-MINI module. Since the ESP32-P4 itself does not include native Wi-Fi or Bluetooth connectivity, the ESP32-C6 serves as a dedicated wireless coprocessor, providing Wi-Fi 6 (802.11ax) and Bluetooth Low Energy (BLE 5.x) capabilities. This combination allows developers to leverage the processing power of the ESP32-P4 while maintaining modern wireless connectivity for IoT and connected-device applications.

You can check out more details about this board from Wavshare's WIKI PAGE.

https://docs.waveshare.com/ESP32-P4-WIFI6-Touch-LCD-4.3

In the Waveshare ESP32-P4 Wi-Fi 6 Touch LCD Kit, an onboard compatible speaker is included.

This speaker serves as a crucial component of our build, as it will be used to output the various astromech sound effects generated by the system.

1. To install the speaker, we first removed the protective layer from the 3M double-sided adhesive tape attached to its back.
2. The speaker was then carefully positioned in the center of the board, directly above the ESP32-P4 metal shielding can, ensuring that it did not interfere with any connectors or components.
3. Once aligned correctly, the speaker was pressed firmly into place, securing it to the board and completing the installation.

1. We start the greebles assembly process by placing the Grill part in its position first. It is pressed firmly into place and gets locked in position due to the zero surface clearance.
2. Next, we apply super glue to the mounting positions of the other greeble parts, then position them one by one.

All parts require some super glue for mounting.

1. Next, we connect our switchboard to the ESP32-P4 Board.
2. We connect the GND pin of the switchboard to the GND pin of the ESP32-P4, GPIO48 to Button 1, and GPIO47 to Button 2.
3. For these connections, single-core silver-copper wire is used.

The 3D-printed switch actuators were positioned in place from inside the main enclosure.

Next, the switch PCB is slid into position slightly below the switch actuators. It is pressure-fitted in place and remains securely fixed.

The ESP32-P4 board is placed into position from the inside of the main enclosure. To secure it in place, hot glue is applied around all four corners of the display, firmly attaching it to the 3D-printed enclosure.

I've been watching James's channel a lot recently, and I really like how he uses hot glue in many of his builds instead of overengineering screw bosses, brackets, and retainers just to hold a part in place. For non-load-bearing components, it's a simple, fast, and surprisingly effective solution.

For the power source, I am using a standard 3.7 V, 2200 mAh 18650 lithium-ion cell. A JST connector has been added to the battery, making it compatible with the ESP32-P4 board's battery connector.

A small amount of hot glue is applied to the battery mounting area, and the cell is placed on top of it. Once the glue hardens, the battery is securely held in position.

Finally, using a pair of tweezers, the JST connector from the battery is plugged into the ESP32-P4 board's battery connector, completing the internal power setup.

Finally, the back lid is placed in position, and four M2 screws are used to secure both enclosure parts together, completing the assembly process.

The code for this project was done in collaboration with Aahan Sharma; he took care of the whole code part.

Full code can be found here on his GitHub page: https://github.com/AahanDoesGit/r2d2

While trying to build this project, I struggled to get the ESPIDF VS Code extension working properly on my MacBook. The paths and Python environments can sometimes get tangled. I found that setting up ESP-IDF purely via the macOS Terminal is much cleaner

Install Dependencies

First, install the required build tools using Homebrew:

Download ESP-IDF (v5.4)

Create a directory for your Espressif tools and clone the specific ESP-IDF release branch. We used 5.4.x because it includes critical support for the new ESP32-P4 chip:

Install the Toolchain

Navigate into the newly cloned directory and run the install script. This downloads the correct compilers (like the RISC-V GCC toolchain for the P4) and creates an isolated Python virtual environment:

The Golden Rule (Exporting the Environment)

Every time you open a new Terminal window to work on your project, you must "source" the ESP-IDF environment. If you don't do this, you will get a zsh: command not found: idf.py error!

Building and Flashing

With your environment active, navigate to your project folder (e.g., cd ~/esp/r2d2-system). You can now build, flash, and monitor the serial output with a single command:

Booting Up (main.c)

The entry point of our application is app_main. Its job is to initialize the hardware peripherals and spin up our individual subsystems

We mount the SD card first because the display needs to load fonts and GIFs, and the audio needs to allocate buffers

The Network: ( r2d2_wifi.c)

Connecting to Wi-Fi on an ESP32 involves the Event Loop. Don't just connect; we register handlers that listen for events like WIFI_EVENT_STA_START or IP_EVENT_STA_GOT_IP.

Eliminating Wi-Fi Latency

By default, ESP-IDF puts the Wi-Fi modem into Power Save Mode, which is 300-500ms delayed.

The Voice of R2-D2: ( r2d2_audio.c )

This generates a tone mathematically.

To play a sound, we generate a Sine Wave into a PCM buffer and send it to the ES8311 I2S Audio Codec

Translating Text to Beeps

When you type "Hello" into the dashboard, we take the ASCII value of each character to seed our procedural math

The Physical Screen: ( r2d2_display.c)

We created a retro-futuristic RADAR UI using standard LVGL components

Hardware mutex locks

Because FreeRTOS runs the UI on Core 0, but our Web Server also runs on Core 0 or 1 might try to change the screen text. We wrap every LVGL call with a Mutex Lock provided by the BSP (Board Support Package)

The Star Wars Frontend

Before we look at the C code that serves the website, we will explore how we built the actual Star Wars-themed frontend interface, the entire frontend HTML, CSS, and JavaScript, into the ESP32 firmware as a massive C string.

The Cinematic Layout & Animations

We didn't just want a boring dashboard; we wanted an immersive Star Wars experience. To achieve this without heavy image files, we relied heavily on Pure CSS

We also added CSS objects for an X-Wing and TIE Fighter flying across the screen, using @keyframes to animate their left and top properties infinitely.

Dynamic JavaScript & Buttons

The frontend uses the modern JavaScript fetch API to communicate with the ESP32 without requiring page reloads.

The Transmit to Droid Button

When you type a phrase and click the transmit button, JavaScript grabs the value and sends an HTTP POST request to the ESP32

Polling System Status

To keep the dashboard updated with the droid's current state (e.g., the system time, current mode

This is how the web browser stays perfectly synced with physical hardware

The Backend ( r2d2_webserver.c)

We wrote a massive raw string in C containing our HTML, CSS, and JavaScript.

The API Endpoints (The Backend)

The Web UI relies on JavaScript fetch() calls to talk to the ESP32. We set up an HTTP GET handler at /api/status.

Handling the "Transmit to Droid" Button

When you type text and click Transmit, the browser sends an HTTP POST to /api/speak.

Because r2d2_speak_text spins up a new FreeRTOS task, the speak_post_handler returns OK immediately!

Build and Flash Instructions

Clone the repository:

Load the ESP-IDF environment (assuming standard installation path):

Build the firmware:

Flash the firmware and open the serial monitor:

Replace /dev/cu.usbmodem5B5E0698681 with your board's specific port

And here is the final result: a fully functional, talking R2-D2-themed desk bot that doubles as a handy pen holder.

You can store your pens and stuff on the back while the droid keeps you company at your desk. The front screen displays a striking blue background with a red circle that symbolizes R2-D2’s eye, which pulses and animates whenever the droid speaks. It’s the perfect blend of utility and personality, a true desk companion that feels like it’s come to life right in front of you.

Every 20 seconds, the device plays a 5-second sequence of random astromech beeps and chirps. Instead of playing static files, it uses math to pick random frequencies and then bends the pitch up and down in real time. Because of this randomness, the sounds feel just as organic and unpredictable as a real droid would make.

For manual control, I’ve mapped two buttons that do the following functions:

Button 1 triggers our Easter Egg songs. I coded these six special tracks purely using R2-D2’s beep frequencies. The library includes AC/DC’s Back in Black (R2-D2 Edition), Happy Birthday, Rick Astley’s Never Gonna Give You Up (Rickroll!), the Star Wars Main Theme, the Super Mario Bros. Theme, and my personal favorite, the Pokémon Diamond/Pearl Lake Theme.

Button 2 acts as a physical toggle for the screen mode. Even if you don't have the web dashboard open, you can press this button to switch the display back and forth between the Radar UI and GIF play modes.

For now, this project has been completed. Special thanks for reaching this far, and I’ll be back with a new project very soon.