Zenkai Engine

Greetings everyone, and welcome back.

Recently, I spent 4–5 hours debugging a project that simply wouldn’t work. The code was correct. The wiring checked out. The logic made sense, but the system refused to behave. After repeated uploads, pin tests, and firmware rewrites, the frustration stopped being about the bug and started becoming self-doubt.

That moment is exactly why I built the Zenkai Engine.

Inspired by the Saiyan concept of Zenkai. This device acts as a physical mindset reset. I chose Vegeta specifically because his character arc represents disciplined self-improvement through repeated failure.

Vegeta’s entire journey is built on failure, pride, setbacks, and relentless self-improvement. He loses. He struggles. He gets outmatched. But instead of quitting, he trains harder. He confronts his weaknesses. He transforms frustration into fuel. Over time, he doesn’t just grow stronger; he grows wiser.

The Zenkai Engine consists of a full-size Dragon Ball enclosure and is powered by a UNIHIKER K10. When the external button that is shaped like a one-star Dragon Ball is pressed, the device plays a short animated sequence of Vegeta standing in rain along with a one-minute motivational speech. After inactivity, the display powers down to conserve energy, awaiting the next trigger.

This article walks through the complete build process of this project, so let's get started.

MATERIALS REQUIRED

These were the materials used in this project:

• Breadboard PCB (Provided by NextPCB)
• Unihiker K10 Dev Board
• Lithium Cell for power
• USB Cable
• M2 screws
• 12x12 Push Switch
• USB Type C Cable 3m
• 3D-printed parts
• Paint (optional)

About Zenkai Boost and Idea Behind Motivation

In Dragon Ball, the concept of a Zenkai Boost refers to the Saiyan ability to grow significantly stronger after recovering from near defeat. Instead of being weakened by loss, they come back more powerful. Damage becomes data. Failure becomes fuel. What makes this idea compelling is not just the ability itself, but how it is represented through characters, especially Vegeta.

Vegeta does not start as the strongest hero. In fact, he is repeatedly outmatched. He loses. He struggles. He trains alone. What defines him is not natural superiority but relentless self-improvement. He refuses to stay behind. He works harder than anyone else, including the hero. Every defeat becomes a reason to push further.

When a project fails, it feels like a setback. Hours of work may seem wasted, but in reality, every failed attempt, every wiring mistake, every blown microcontroller, and every debugging session adds experience. You may not see immediate progress, but you are improving.

The Zenkai Engine is a physical reminder of that principle.

When something doesn’t work, I press the button, listen to the speech, reset my mindset, and return to the problem.

HARDWARE—Unihiker K10

The star of this project is the UNIHIKER K10, which serves as the core controller and display unit for the entire system.

The UNIHIKER platform is available in two variants: the M10 and the K10.

The M10 is based on a Linux-capable processor, designed for higher-level applications.

The K10, on the other hand, is powered by the ESP32-S3 N16R8 module.

Key Specifications:

• Module: ESP32-S3 N16R8
• Processor: Xtensa® LX7 dual-core 32-bit CPU
• Clock Speed: Up to 240 MHz
• SRAM: 512 KB
• ROM: 384 KB
• Flash Memory: 16 MB
• PSRAM: 8 MB
• RTC SRAM: 16 KB

With its dual-core architecture and generous Flash and PSRAM, the ESP32-S3 is capable of handling image rendering, SD card file access, and audio playback simultaneously

Our primary reason for selecting the UNIHIKER K10 for this project was its built-in SD card reader and onboard speaker. These two features significantly simplified the overall design and eliminated the need for additional external modules.

All media assets used in the Zenkai Engine are stored directly on the SD card. This includes the image frames used to simulate the animated sequence, as well as the audio file that plays during activation.

The display renders JPG images read from the SD card in rapid succession to recreate the animated effect. For audio playback, the system uses a WAV format file, as this is the supported and most reliable format for playback through the onboard speaker.

By handling both image rendering and audio output internally, the UNIHIKER K10 serves as a compact, all-in-one solution for managing the interactive and multimedia aspects of the project.

Check out more about the Unihiker K10 from its wiki page.

https://www.unihiker.com/wiki/K10/

PCB BREADBOARD

For this project, I used one of my previously designed PCB breadboards, created specifically to suit my personal prototyping workflow.

The board includes an integrated USB Type-C input for power delivery, along with an M7 forward diode for reverse polarity protection. This ensures safe and reliable operation during development and testing.

To support SMD prototyping, a dedicated SOIC-8 footprint was incorporated into the design. This makes it possible to work with surface-mount ICs in SOIC-8 packages, which is particularly useful when a component is not available in a through-hole variant.

For added functionality and visual feedback, the PCB also features a footprint for a WS2812B addressable RGB LED. Additionally, a 0603 LED footprint is included for simple status indication when required.

The overall layout mirrors that of a traditional solderless breadboard, allowing for a familiar workflow. However, unlike a standard breadboard where the central columns are internally connected vertically, the middle section of this PCB consists of individual, unconnected pads. This design enables complete flexibility, allowing custom connections to be created manually rather than being constrained by fixed internal traces.

The VCC and GND rails are arranged identically to a conventional breadboard, ensuring an intuitive transition from temporary breadboard prototyping to a more permanent PCB-based implementation.

Check out more about this project from the previous article.

https://www.hackster.io/Arnov_Sharma_makes/dc-pump-driver-with-custom-pcb-breadboard-cdf568

NextPCB PCB SERVICE

After completing the PCB design, Gerber data was sent to HQ NextPCB, and an order was placed for a yellow solder mask with white silkscreen.

After placing the order, the PCBs were received within a week, and the PCB quality was pretty great.

In addition, I have to bring in HQDFM to you, which helped me a lot through many projects. Huaqiu’s in-house engineers developed the free Design for Manufacturing software, HQDFM, revolutionizing how PCB designers visualize and verify their designs.

Take advantage of NextPCB's Accelerator campaign and get 2 free assembled RP2040-based PCBs for your innovative projects.

https://www.nextpcb.com/blog/rp2040-free-pcba-prototypes-nextpcb-accelerator

This offer covers all costs, including logistics, making it easier and more affordable to bring your ideas to life. SMT services can be expensive, but NextPCB is here to help you overcome that hurdle. Simply share your relevant project, and they'll take care of the rest. Don't miss out on this amazing opportunity to advance your tech creations!

HQDFM: Free Online Gerber Viewer and DFM Analysis Tool

Also, NextPCB has its own Gerber Viewer and DFM analysis software.

Your designs are improved by their HQDFM software (DFM) services. Since I find it annoying to have to wait around for DFM reports from manufacturers, HQDFM is the most efficient method for performing a pre-event self-check.

This is what I see in the online Gerber Viewer. It's decent for a quick look but not entirely clear. For full functionality—like detailed DFM analysis for PCBA—you’ll need to download the desktop software. The web version only offers a basic DFM report.

With comprehensive Design for Manufacture (DFM) analysis features, HQDFM is a free, sophisticated online PCB Gerber file viewer.

With over 15 years of industry experience, it offers valuable insights into advanced manufacturing processes. If you’re looking for reliable PCB services at a budget-friendly price, HQ NextPCB is definitely worth checking out.

MAKESHIFT SWITCH PCB

• We needed a small PCB to securely mount our 12×12 mm push button, so we cut a section from the PCB breadboard using a sheet metal cutter. This trimmed piece serves as the switch PCB.
• The push button was positioned at the center of this PCB. The board was then flipped over, and the button leads were soldered in place using solder wire.

ELECTRONICS SETUP

• The main electronics assembly comes next. Two connecting wires were soldered to the switch terminals. Through these wires, the switch PCB was connected to the GND pin and Pin 1 of the UNIHIKER.
• Next, a 3.7V 600mAh lithium cell was connected to the battery terminals of the UNIHIKER. This will serve as the primary power source for the device.

Preparing GIF

Now comes one of the most critical parts of this project: the animated GIF.

Initially, I selected a short looping GIF of Vegeta standing in the rain.

Ideally, the process would be simple: place the GIF file on the SD card and let the UNIHIKER play it directly. However, the UNIHIKER does not support native GIF playback. It can only display static images stored on the SD card.

To work around this limitation, I used EZGIF to process the animation. First, the original GIF was resized to 320×240 pixels to match the UNIHIKER’s display resolution.

Next, the GIF was split into individual frames. Each frame was exported in JPG format.

The idea is straightforward: instead of playing a GIF file, we rapidly display multiple JPG frames in sequence. By cycling through these images at a fixed frame rate, we simulate motion and recreate the animated effect.

UNIHIKER K10 CORE INSTALLATION

Before uploading the code to the UNIHIKER, we first need to install the Arduino core for the UNIHIKER K10 by following the installation guide provided on DFRobot’s official wiki.

We copy and paste the provided board manager URL into the Additional Board Manager URLs section in the Arduino IDE settings.

https://downloadcd.dfrobot.com.cn/UNIHIKER/package_unihiker_index.json

Next, we open the Boards Manager, search for UNIHIKER K10, and install the required board package. Once installed, this allows us to select the UNIHIKER K10 from the board selection menu in the Arduino IDE.

MAIN CODE & DEMO

Here's the code we used in this build, and it's a simple one.

#include "unihiker_k10.h"
UNIHIKER_K10 k10;
Music music;
// -------- SCREEN --------
uint8_t screen_dir = 2;
#define ORANGE 0xFFA500
#define BLACK  0x000000
// -------- BUTTON --------
#define EXT_BUTTON_PIN 2   // P2 (INPUT_PULLUP)
// -------- TIMING --------
#define FRAME_DELAY        100
#define AUDIO_DURATION     63000      // 1 min 3 sec
#define DISPLAY_OFF_TIME   180000     // 3 minutes
// -------- FRAMES --------
const char* frames[] = {
"S:/IMG01.jpg",
"S:/IMG02.jpg",
"S:/IMG03.jpg",
"S:/IMG04.jpg"
};
const int frameCount = 4;
// -------- STATE --------
enum DeviceState {
DISPLAY_OFF,
IDLE_ON,
PLAYING
};
DeviceState state = IDLE_ON;
unsigned long lastActivityTime = 0;
// -------- AUDIO TASK --------
void audioTask(void *param) {
music.playTFCardAudio("S:/WAVE01.wav");
vTaskDelete(NULL);
}
// -------- UI --------
void showOrange() {
k10.canvas->canvasRectangle(0, 0, 240, 320, ORANGE, ORANGE, true);
k10.canvas->updateCanvas();
}
void showBlack() {
k10.canvas->canvasRectangle(0, 0, 240, 320, BLACK, BLACK, true);
k10.canvas->updateCanvas();
}
// -------- SETUP --------
void setup() {
k10.begin();
k10.initScreen(screen_dir);
k10.creatCanvas();
k10.initSDFile();
pinMode(EXT_BUTTON_PIN, INPUT_PULLUP);
showOrange();
state = IDLE_ON;
lastActivityTime = millis();
}
// -------- LOOP --------
void loop() {
unsigned long now = millis();
// -------- DISPLAY TIMEOUT --------
if (state == IDLE_ON && (now - lastActivityTime >= DISPLAY_OFF_TIME)) {
showBlack();
state = DISPLAY_OFF;
}
// -------- BUTTON PRESS --------
if (digitalRead(EXT_BUTTON_PIN) == LOW) {
while (digitalRead(EXT_BUTTON_PIN) == LOW); // wait release
delay(200);
lastActivityTime = millis();
// ---- CASE 1: DISPLAY OFF → TURN ON ONLY ----
if (state == DISPLAY_OFF) {
showOrange();
state = IDLE_ON;
return;
}
// ---- CASE 2: IDLE ON → START PLAYBACK ----
if (state == IDLE_ON) {
state = PLAYING;
xTaskCreate(audioTask, "AudioTask", 4096, NULL, 1, NULL);
unsigned long startTime = millis();
int frameIndex = 0;
while (millis() - startTime < AUDIO_DURATION) {
k10.canvas->canvasDrawImage(0, 0, frames[frameIndex]);
k10.canvas->updateCanvas();
frameIndex = (frameIndex + 1) % frameCount;
delay(FRAME_DELAY);
}
showOrange();
state = IDLE_ON;
lastActivityTime = millis();
}
}
}

Aside from the code, we used an 8GB SD card formatted in FAT32. Inside the SD card, we added four images named IMG01 to IMG04, along with an audio file named WAVE01 These files are accessed by the UNIHIKER during playback to render the animation and play the motivational speech.

When we power on the device, the display shows an orange idle screen to match the color of the enclosure. When the button is pressed, the device starts the playback sequence, in which images are rapidly cycled to create the illusion of animation while simultaneously playing a WAV audio file.

Once the one-minute sequence completes, the system returns to the orange idle state. If no interaction occurs for three minutes, the display turns off to conserve power. When the button is pressed again, the screen turns orange and the device is ready for playback. This entire setup operates continuously in a loop.

We have attached a small short that shows playback; do check it out for a demo.

DESIGN

After finalizing the electronics, we moved on to the enclosure design. We could have made a simple enclosure to hold the UNIHIKER in place, but that would have been boring. Since we are using Vegeta as our motivational character, we wanted something that could house the UNIHIKER while also looking visually striking. The obvious choice was a Dragon Ball, not just any Dragon Ball, but the larger Namekian Dragon Ball from Planet Namek, which is bigger than its Earth counterpart.

Unfortunately, I was not able to create a fully spherical enclosure. For now, I designed only the front portion thick enough to house the UNIHIKER, the switch PCB, and the battery inside.

We used Fusion 360 to model the Dragon Ball. A clear front-facing image of the Dragon Ball was imported using the canvas tool and calibrated to a diameter of 202 mm. The outline of the ball was carefully traced, then hollowed out to create space inside. The UNIHIKER was positioned centrally within the enclosure, and a window was created so the screen would remain visible from the front.

Below the screen, a single star was modeled by tracing its outline. This star serves as the external button. Directly beneath the star, we placed the switch PCB so that pressing the star would mechanically actuate the switch, which the UNIHIKER registers as a button press.

To secure the switch PCB in position, two mounting holders were modeled inside the enclosure. The switch PCB is attached using two M2 screws, ensuring stability and proper alignment.

The entire design was built around maintaining the aesthetic of Dragon Ball. No extra elements such as rocker switches or visible hardware were added that would disrupt its original look.

After finalizing the design, we exported the mesh files for both the Dragon Ball enclosure and the button. The Dragon Ball was printed using Orange Hyper PLA with a 0.16 mm layer height and 25% infill. We used normal supports with a snug support type, which allowed the support material to be removed easily without applying excessive force.

Similarly, the star button was printed using the same settings, with the only change being the filament color, switching from orange to red.

PAINT

We printed the Dragon Ball using orange PLA, which already matched the base color of the Dragon Ball. However, the original Dragon Ball has subtle highlights and shading that give it a glass-like appearance. A single flat orange print did not capture that effect.

To recreate the original color palette, we decided to paint the enclosure. We used orange acrylic paint as the base and mixed in small amounts of yellow to create lighter tones and red to produce darker shades. This allowed us to manually build depth and highlight areas to mimic the natural reflections seen on the Dragon Ball.

Using a 5 mm brush and a reference image of the Dragon Ball, we hand-painted the front surface. The result was a significantly improved finish that looks much closer to an authentic Dragon Ball, except for the glossy glass-like shine.

This step was entirely optional and not required for functionality, but it was important to achieve a more accurate and visually appealing final result.

ASSEMBLY PROCESS

• First, the UNIHIKER was placed inside the enclosure in its designated position, followed by positioning the lithium cell above the UNIHIKER.
• Hot glue was used to secure the UNIHIKER in place by applying it along the edges of the board. A small amount of hot glue was also applied to the lithium cell to keep it firmly fixed in position.
• Next, the star-shaped button was inserted from the inside of the enclosure. The switch PCB was then positioned directly above the star button and secured in place using two M2 screws.
• Finally, a 3-meter USB Type-C cable was connected to the UNIHIKER. The enclosure includes internal ribs with dedicated slots that allow the cable to pass through neatly and exit from the bottom of the device.
• This USB cable is connected to a 5V charger to power the system continuously. In the event of a power outage, the internal lithium battery automatically powers the device.

With this, the assembly process of our Zenkai Engine is complete.

RESULT

To mount the device, we placed two nails on the wall, allowing us to hang the Dragon Ball securely near the workstation where I spend most of my time. It is positioned on the right side of where I sit, making it easily accessible whenever I need it.

Whenever I feel demotivated or stuck on a problem, I simply press the star button. Vegeta’s voice plays through the Zenkai Engine, delivering a short burst of motivation that helps reset my mindset and push forward again.

When not in use, the device automatically turns its screen off after a few minutes to conserve power. A single press of the button brings the display back to life with the orange idle screen, which indicates the system is ready. Pressing the button again starts the full playback sequence, triggering both the animated display and the motivational audio.

The Zenkai Engine is more than just a decorative piece. It functions as a physical reset switch for my mindset, a reminder that frustration is part of growth. Instead of walking away from a problem, I now have a ritual: press the button, refocus, and return to work.

Mounted beside the workstation, it blends into the environment as a Dragon Ball, but its purpose goes beyond aesthetics.

Special thanks to HQ NextPCB for providing components that I've used in this project; check them out for getting all sorts of PCB or PCBA-related services for less cost.

All the details are covered in this article—feel free to reach out if you need any help regarding the project.

Peace!