Mega Man's Mega Buster

Greetings everyone, and welcome back!

This is Mega Man’s Mega Buster, also known as the Rock Buster (or ROKKU BASUTA in Japan), which I built completely from scratch.

This is a fully working replica. I started by modeling the Mega Buster in Fusion 360 and then added electronics inside to replicate both the plasma blaster effect and the side power indicator. The entire setup is powered by a Raspberry Pi Pico, paired with a custom power circuit using a lithium battery, making it a wearable prop. I’ve also added an internal speaker to bring sound effects to life.

The goal of this project was simple: I’m planning to attend an upcoming Comic Con event in Gurugram, and I wanted to create a quick, wearable gauntlet-style prop. I won’t be wearing the full suit—just the gauntlet—and the Mega Buster is something I’ve always wanted to build. I used to play Mega Man X on my Windows 98 PC years ago. The game was brutally hard, but it was a big part of my childhood, and I wanted to bring a piece of that nostalgia into the real world. That’s why I chose the Mega Buster.

Here's how it works: inside the Mega Buster, there’s a push button used to trigger the firing sequence. When the button is pressed and held, the blaster begins charging and plays a charging sound effect. Once the button is released, the front red LED flickers, simulating the firing of a plasma beam.

The plasma beam remains active for the duration of the button press; the longer the button is held, the longer the beam fires. After firing, the effect slowly fades out and turns off.

On the side of the blaster, there’s a six-bar power indicator that acts like an ammo meter. Each time the plasma beam is fired, one bar is depleted. Once all six bars are empty, the side indicator, front blaster LED, and speaker all blink red for 10 seconds, indicating a cooldown period. After the cooldown finishes, the device resets and power is fully restored.

This Article covers the complete build process of the project from design to electronics and final assembly.

Let’s get started.

MATERIALS REQUIRED

These were the materials used in this project:

• Custom PCBs (All three Provided by NEXTPCB)
• Raspberry Pi PICO
• IP5306
• WS2812B LED
• 10 uF 1206 Capacitors
• 100 nF 0805 capacitors
• 8205S Mosfet IC
• 10K Resistors
• Push Button - Rocker Switch
• 3D Printed Parts
• M2 Screws
• Connecting wires
• PAM8403 AMP
• 8-Ohm 2W Speaker

MEGAMAN

For anyone unfamiliar, Mega Man, also known as Rockman in Japan, is a classic action-platformer franchise created by Capcom. The series follows a humanoid robot named Mega Man, originally called Rock, who battles rogue robots using special weapons acquired from defeated enemies. One of the most iconic elements of the franchise is the Mega Buster, an arm-mounted energy cannon capable of firing charged energy shots.

Since its debut in the late 1980s, the Mega Man franchise has become known for its tight controls, memorable music, and challenging gameplay, earning a dedicated fan base across multiple generations.

My introduction to the Mega Man universe came through Mega Man X. Unlike the original Mega Man series, Mega Man X does not focus on the original Mega Man (Rock). Instead, the main protagonist is X, a new-generation robot created by Dr. Light. X is designed with the ability to think, feel, and make moral decisions, which gives the Mega Man X series a darker and more mature tone compared to the classic games.

Another major difference introduced in the Mega Man X series is Zero. Zero is a powerful ally and sometimes rival who uses a beam saber instead of an arm cannon. While early Mega Man X games focus mainly on X, later titles allow players to switch between X and Zero, each offering distinct fighting styles, abilities, and upgrades.

Now that the basics are covered, let’s move on to the project.

https://megaman.fandom.com/wiki/Mega_Man_Knowledge_Base

DESIGN

We start the 3D model-making process by first getting a reference image of the Rock Buster from the internet. We import the image into Fusion 360 through the canvas option, then use the calibration function to set the length of the whole gauntlet to 330 mm.

The whole gauntlet is symmetrical, so we can easily make this using the revolve function. To do this, we trace the outline of the gauntlet and then use the revolve function to make a solid gauntlet body.

For the engineering process, we first divide the body into three main sections. The front part is the blaster section, the middle body is a hollow part in which we add the handle grip that is used to hold the whole gauntlet, and inside this section we also add the main control circuit. The third part is the back section, which contains a cushion that supports our arm.

The middle body, or main body, on the left side contains a replica of the yellow power bar. This part is basically a slot made in the middle body in which we modeled a PCB that contains RGB LEDs. These LEDs glow yellow. Over these LEDs, we have placed a diffuser part that makes the whole power indication section look like the actual Mega Man gauntlet yellow bar.

Similarly, the front part contains the blaster PCB, which has a regular red LED. Over this LED, we have modeled a diffuser that is held in place using snap locks.

The handle grip is modeled to hold a push switch. We took the concept for this from a drill handle, which contains a button in a similar way. The handle grip contains four screw bosses that are used to secure it in place inside the main body. In the main body, we have made a slot in which the handle grip slides into place, which makes the assembly very easy. It is basically a place-and-drop assembly. When the handle is placed inside, four M2 screws are added, which join the handle with the screw bosses inside the main body.

The back part is added and placed on the backside of the main body. Both of these parts are held together using only tolerance. Usually, we add 0.15 to 0.2 mm tolerance between two 3D-printed parts when attaching them together, but in this case, we added zero clearance between the parts, which allows us to pressure-fit both parts into position.

3D PARTS

After completing the CAD model, all 3D mesh files were exported from Fusion 360 at the highest quality and then imported into the slicer one by one for 3D printing.

We began by printing the main body separately, as it is the largest part of the build. This single part took approximately 19 hours to print. The print was done using an Anycubic Kobra S1, using Hyper PLA with tree supports enabled for better overhang handling and easier support removal.

Using the same print settings, the back ring and front section were printed in blue Hyper PLA to maintain color consistency across the main structure.

The side diffuser and front diffuser were printed using transparent Hyper PLA, allowing light to pass through evenly. The handgrip was printed in white Hyper PLA for contrast and comfort.

Tree supports were used for all parts, which made support removal easy and resulted in clean prints. Thanks to the high print quality, none of the parts required any post-processing or surface finishing before assembly.

PCB DESIGN

For this project, we designed a total of three PCBs: the main circuit, which acts as the driver and power board of the project; the side power indicator board, which consists of WS2812B LEDs to imitate the side yellow power bar; and the front blaster PCB, which contains a red LED that imitates the blast.

MAIN CIRCUIT

The main circuit consists of a power management IC setup paired with a Raspberry Pi Pico. Let’s have a brief breakdown of the circuit schematic.

We are using the Pico to control all our electronics, such as the front blaster PCB, side LED indicator PCB, push button, and audio amplifier—all of which are connected to the Pico.

For power, we wanted to use a LiPo cell, as it can easily fit inside the blaster. However, the Pico and other electronics require a stable 5 V, while a LiPo cell outputs only 3.7 V. To solve this, we used a power management IC, specifically the IP5306, which takes a 3.7 V lithium cell as input and provides a stable 5 V, 2 A output. It also includes complete charging and discharging circuitry, along with indicator LEDs that show battery charging status, full charge, and low battery conditions.

For adding peripherals such as the front blaster LED, side LED, and audio module, we added connector terminals on the PCB.

• CON3 provides 5 V, GND, and GPIO17 for the side LED indicator.
• Another connector provides 5 V, GND, and GPIO16 for the front blaster LED.
• CON2 is used for the push switch, with GND and GPIO15 connections.

Additionally, we added a footprint for a MAX98357A audio amplifier, but in the final build, we ended up using a PAM8403 audio amplifier with the Pico.

After finalizing the PCB, we converted the schematic into a PCB file. The board outline and component placement were all done by following the PCB CAD file we modeled in Fusion 360.

FRONT BLASTER

The front blaster PCB is unique. We have used 10 red LEDs in 2835 packages, all connected in parallel, with each LED drawing around 0.1 W of power. One or two LEDs can be directly connected to a GPIO pin, but using this many LEDs is not recommended, as it can damage the board.

To prevent this, we used an N-channel MOSFET as a switching setup to drive the LEDs. The VCC terminal is connected to the anodes of all the LEDs, while the cathodes of the LEDs are connected to the drain of the MOSFET IC, which in our case is the 8205S. The source of the MOSFET is connected to GND.

We have added two 10 kΩ resistors: one is connected between the DIN pin and the gate of the MOSFET, and the other is connected between the gate and source. Additionally, we have added four 1206-package current-limiting resistors between VCC and the anodes of the LEDs. These resistors limit the current passing through the LEDs and protect them from overcurrent.

For this board, the LEDs are placed in a circular pattern, which is time-consuming to design directly in PCB CAD software. To simplify this, I exported the DWG file of the entire board from the CAD model and imported it into my PCB CAD software. Using the LED outlines from the DWG file as a reference, I aligned and placed the SMD LEDs accurately. This allowed us to create the front blaster PCB exactly as per the CAD model.

SIDE POWER INDICATOR

For the side power indicator, we have used six WS2812B LEDs, all linked together in their usual configuration. The DOUT of the first LED goes into the DIN of the second LED, the DOUT of the second LED goes into the DIN of the third LED, and this continues up to the sixth LED.

Each LED is paired with a 100 nF decoupling capacitor, which is placed close to the LED’s VCC and GND pads during the PCB design process to ensure stable operation.

For the board outline, mounting holes, and LED placement, we used the CAD model as a reference.

NextPCB PCB SERVICE

After completing the PCB design, Gerber data for all three PCBs was sent to HQ NextPCB, and an order was placed for two boards with a blue solder mask and one board with a red solder mask.

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.

PCB ASSEMBLY PROCESS- MAIN CIRCUIT

• We begin the main board assembly process by first adding solder paste to each component pad using a solder paste dispensing syringe. We are using SnPb 63/37 solder paste here, which has a melting temperature of 200°C.
• Next, we pick and place the Raspberry Pi Pico in its location over the footprint, followed by all the SMD components.
• The whole circuit is then placed on a reflow hot plate, which heats the PCB from below up to the solder paste melting temperature. When the PCB reaches 200°C, the solder paste melts and all components are secured in their locations.
• Next, we add the Type-C port in its location, followed by the vertical push button.
• The board is then flipped over, and the leads of the Type-C port and push button are secured using solder.

POWER SOURCE TEST

For the power source of this project, a 3.7 V, 1000 mAh lithium-polymer (Li-Po) cell is used. The positive terminal of the battery is connected to the B+ terminal on the main board, while the negative terminal is connected to B−.

A vertical push button is used as the power switch. When the button is pressed, the circuit powers on.

To verify proper operation, a multimeter is used to measure the voltage across the 5 V and GND pins on the main board. A stable reading of 5 V confirms that the power circuit is functioning correctly and the setup is ready for operation.

MAIN BOARD AUDIO MODULE ASSEMBLY & DEMO

A speaker cannot be connected directly to the Raspberry Pi Pico’s GPIO pins for practical audio output. While it may work electrically, the sound level is extremely low and not suitable for a wearable prop. To solve this, an external audio amplifier is required to boost the Pico’s audio signal.

For this project, I used the PAM8403 audio amplifier module. The PAM8403 is a compact Class-D amplifier capable of driving small speakers efficiently.

The wiring was done as follows:

• PAM8403 R input to GPIO26 of the Raspberry Pi Pico
• PAM8403 GND to GND
• PAM8403 5V to 5V output from the custom power circuit

For the speaker, I used an 8-ohm, 2-watt speaker salvaged from an old laptop. The speaker was connected to the R output terminals of the PAM8403 amplifier board.

After completing the wiring, a simple test sketch was uploaded to the Pico.

#define AUDIO_PIN 26
#define BLAST_TIME   2000
#define SILENT_TIME  2000
void setup() {
pinMode(AUDIO_PIN, OUTPUT);
}
void loop() {
unsigned long start = millis();
while (millis() - start < BLAST_TIME) {
// Fast pitch sweep = blaster feel
for (int f = 1200; f > 400; f -= 30) {
tone(AUDIO_PIN, f);
delay(2);
}
}
noTone(AUDIO_PIN);
delay(SILENT_TIME);
}

The speaker successfully produced a stable beep for a few seconds, turned off, and then repeated the sequence in a loop. This confirmed that the amplifier and speaker setup were working perfectly.

PCB ASSEMBLY-FRONT BLASTER

Next, we begin the assembly process of the front blaster PCB.

• The process starts by applying solder paste to each component pad on the PCB.
• Once the solder paste is applied, the SMD red 2835 LEDs are placed onto their respective footprints. This is followed by placing the MOSFET IC and the SMD resistors, using tweezers to accurately position each component.
• After all components are placed, the PCB is carefully transferred to a reflow hot plate. The hot plate heats the PCB from below until it reaches the solder paste melting temperature. As the board reaches 200°C, the solder paste reflows and securely bonds all components to the PCB.
• To verify that all LEDs are soldered correctly, a multimeter set to diode test mode is used. The positive probe is placed on the VCC rail of the LED board, while the negative probe is connected to the drain terminal of the MOSFET. If all LEDs illuminate, it confirms that the soldering and connections are correct.

PCB ASSEMBLY PROCESS- SIDE POWER INDIACTOR LED BOARD

Next, we begin the assembly of the side power indicator LED board.

• Similar to the previously assembled PCBs, the process starts by applying solder paste to each SMD component pad on the board.
• Once the solder paste is applied, all SMD components are placed using tweezers. This includes six 100 nF capacitors in 0805 packages, followed by six WS2812B addressable LEDs, each positioned carefully in its designated footprint.
• After component placement, the PCB is transferred to a reflow hot plate. The board is heated until the solder paste reaches its melting temperature, allowing it to reflow and securely bond all components in place.

MAIN ELECTRONICS SETUP

After finalizing all PCBs, we move on to the final wiring stage, where the front blaster PCB and the side power indicator LED board are connected to the main circuit.

Front Blaster PCB Connections

The front blaster PCB is wired to the main board as follows:

• VCC to 5V from the main circuit
• GND to GND of the main circuit
• DIN to GPIO17 of the Raspberry Pi Pico

Side Power Indicator LED Board Connections

Next, the side power indicator board is connected:

• VCC to 5V from the main circuit
• GND to Common ground
• DIN to GPIO16 of the Pico

Battery Connection

Once both LED boards are connected, the battery is reconnected to the main board:

• Battery positive to B+
• Battery negative to B—

Audio Amplifier Recap

The PAM8403 audio amplifier connections are as follows:

• GPIO26 to PAM8403 R input
• GND to GND
• VCC to 5V

Push Button Connection

The push switch is connected to control the firing action:

• One terminal of the switch to GPIO15
• Other terminal to GND

Pressing the switch pulls GPIO15 low, allowing the firmware to detect a button press.

Note: Although the switch looks like a regular rocker switch, it is actually a spring-loaded bell-type rocker switch, meaning it behaves like a momentary push button and returns to its default position when released.

MAIN CODE

Here's the main code we prepared for our blaster, and it's a simple one.

#include <Adafruit_NeoPixel.h>
#define AUDIO_PIN    26
#define BUTTON_PIN   15
#define BLAST_LED    17
#define PIXEL_PIN    16
#define PIXEL_COUNT  6
#define MAX_CHARGE_TIME 3000
#define MAX_AMMO        6
#define COOLDOWN_TIME   10000
// Software volume control (percent)
#define AUDIO_VOLUME   60   // 100 = max, 60 = mid
// Front blast LED brightness cap (70%)
#define BLAST_LED_MAX  180  // ~70% of 255
// WS2812B colors
#define AMMO_YELLOW   strip.Color(255, 160, 0)
#define OVERHEAT_RED  strip.Color(255, 0, 0)
Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
int ammo = MAX_AMMO;
bool coolingDown = false;
void setup() {
pinMode(AUDIO_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(BLAST_LED, OUTPUT);
strip.begin();
strip.setBrightness(180);
strip.show();
randomSeed(analogRead(0));
refillAmmo();
}
void loop() {
if (coolingDown) return;
if (digitalRead(BUTTON_PIN) == LOW && ammo > 0) {
chargeAndFire();
ammo--;
updateAmmoBar();
if (ammo == 0) {
startCooldown();
}
}
}
// ================= CHARGE =================
void chargeAndFire() {
unsigned long startTime = millis();
unsigned long heldTime  = 0;
while (digitalRead(BUTTON_PIN) == LOW) {
heldTime = millis() - startTime;
if (heldTime > MAX_CHARGE_TIME) heldTime = MAX_CHARGE_TIME;
int chargeFreq = map(heldTime, 0, MAX_CHARGE_TIME, 300, 900);
tone(AUDIO_PIN, chargeFreq);
delay(15);
}
noTone(AUDIO_PIN);
fireBlast(heldTime);
}
// ================= BLAST =================
void fireBlast(unsigned long blastTime) {
if (blastTime < 120) blastTime = 120;
int startFreq = map(blastTime, 0, MAX_CHARGE_TIME, 900, 2400);
int step      = map(blastTime, 0, MAX_CHARGE_TIME, 25, 70);
unsigned long start = millis();
unsigned long gate  = 0;
while (millis() - start < blastTime) {
for (int f = startFreq; f > 300; f -= step) {
gate++;
if ((gate % 100) < AUDIO_VOLUME) {
tone(AUDIO_PIN, f);
} else {
noTone(AUDIO_PIN);
}
// Front LED aggressive flicker, capped at 70%
for (int i = 0; i < 3; i++) {
analogWrite(BLAST_LED, random(60, BLAST_LED_MAX));
delayMicroseconds(400);
}
delay(2);
}
}
noTone(AUDIO_PIN);
// Front LED cooldown (fade from 70% to off)
for (int i = BLAST_LED_MAX; i >= 0; i--) {
analogWrite(BLAST_LED, i);
delay(5);
}
}
// ================= AMMO BAR =================
void refillAmmo() {
ammo = MAX_AMMO;
for (int i = 0; i < PIXEL_COUNT; i++) {
strip.setPixelColor(i, AMMO_YELLOW);
}
strip.show();
}
void updateAmmoBar() {
for (int i = 0; i < PIXEL_COUNT; i++) {
if (i < ammo) {
strip.setPixelColor(i, AMMO_YELLOW);
} else {
strip.setPixelColor(i, 0);
}
}
strip.show();
}
// ================= COOLDOWN =================
void startCooldown() {
coolingDown = true;
unsigned long start = millis();
while (millis() - start < COOLDOWN_TIME) {
for (int i = 0; i < PIXEL_COUNT; i++) {
strip.setPixelColor(i, OVERHEAT_RED);
}
strip.show();
analogWrite(BLAST_LED, BLAST_LED_MAX);
delay(300);
strip.clear();
strip.show();
analogWrite(BLAST_LED, 0);
delay(300);
}
refillAmmo();
coolingDown = false;
}

In our sketch, we have only used one library, which is the Adafruit Neopixel Library; you need to install it before compiling the code.

#define AUDIO_PIN    26
#define BUTTON_PIN   15
#define BLAST_LED    17
#define PIXEL_PIN    16
#define PIXEL_COUNT  6

Audio Pin is the amplifier input pin, which we use GPIO26 for; Button Pin is GPIO15; Front Blaster Pin is GPIO17; and Neopixel Pin, or Side Power Board Din Pin, is connected to GPIO16, and we have also declared the Pixel Count, which is 6.

#define MAX_CHARGE_TIME 3000
#define MAX_AMMO        6
#define COOLDOWN_TIME   10000

Next we have the timing parameters, which include max charge duration (3 seconds), max ammo, which is a total of six shots before cooldown, and the cooldown timer, which is set to be 10 seconds. We can change the cooldown time to make the cooldown fast or slow by increasing or decreasing the time.

#define AUDIO_VOLUME   60
#define BLAST_LED_MAX  180

Next are the audio and LED limits. These two are added to set the volume limit and LED brightness increase.

Again, these values can be increased or decreased.

#define AMMO_YELLOW   strip.Color(255, 160, 0)
#define OVERHEAT_RED  strip.Color(255, 0, 0)

Next we defined the AMMO yellow color for the available ammo bar and the red color for when in overheating/cooldown mode.

Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, NEO_GRB + NEO_KHZ800);
int ammo = MAX_AMMO;
bool coolingDown = false;

Using this section, WS2812B LEDs are initialized. ammo tracks remaining ammo shots, and cooldown blocks input during cooldown.

void setup() {
pinMode(AUDIO_PIN, OUTPUT);
pinMode(BUTTON_PIN, INPUT_PULLUP);
pinMode(BLAST_LED, OUTPUT);
strip.begin();
strip.setBrightness(180);
strip.show();
randomSeed(analogRead(0));
refillAmmo();
}

This is the setup function; we added general things in the function, like GPIO configuration, initializing LEDs, etc., but the main part in this is the seeds' randomness for natural flicker and filling the ammo bar at startup.

void loop() {
if (coolingDown) return;
if (digitalRead(BUTTON_PIN) == LOW && ammo > 0) {
chargeAndFire();
ammo--;
updateAmmoBar();
if (ammo == 0) {
startCooldown();
}
}
}

Next is our loop function, which ignores all input during cooldown. starts charging when the trigger is pressed and fires on release; it also reduces ammo and updates the LED bar and triggers cooldown when ammo reaches zero.

void chargeAndFire()

This function measures how long the trigger is held; it generates a rising audio tone during charging, it also caps charge time to prevent overcharging, and it calls the firing routine when the button is released. Basically, the longer the press, the higher the charge.

void fireBlast(unsigned long blastTime)

This function controls plasma-like descending audio tones along with aggressive front LED flickering and then smooth LED fade-out after firing. Here the blast duration scales with charge time, closely mimicking Mega Man-style behavior.

void refillAmmo()
void updateAmmoBar()

Each WS2812B LED represents one ammo unit; LEDs turn off as ammo is consumed, and all LEDs turn back on after cooldown.

void startCooldown()

When ammo is depleted, the side LEDs blink red and the front blaster LED pulses; input is ignored for 10 seconds.

FRONT SECTION ASSEMBLY

• The front section assembly process begins by adding the front blaster PCB into position by aligning the mounting holes of the PCB with the screw holes on the body. We use M2 screws to secure the PCB to the body.
• The wires of the PCB are passed through the hole provided in the body from the back side.

MAIN BODY & SIDE POWER LED ASSEMBLY

• We now begin with the side power LED assembly with the main body. We add the side power PCB into position by matching its mounting holes with the screw holes provided on the body. We then use two M2 screws to secure both together.
• Over the PCB, we place the diffuser part, which is pressure-fitted into position. On both sides of the diffuser, we have added snap locks, and when the diffuser is pushed into place, these locks allow it to get securely fixed in position.
• Additionally, to increase the effect of the bar LED, we created a grid-like part that sits inside the diffuser to isolate each LED’s glow. This part ensures that light from each LED falls only on the top side of the diffuser and does not interfere with the left and right sides.

HANDLE GRIP SWITCH ASSEMBLY

• Next, we move on to the handgrip and push-button assembly, which is a very simple step. The switch wires are first passed through the slot provided in the handgrip.
• The switch is pressure-fit into its position, securing it firmly in place without the need for additional fasteners.

BODY ASSEMBLY

• The body assembly process begins by placing the front section assembly onto the main body. The front section is pressure-fitted into position, ensuring a secure fit.
• Next, the handgrip is installed from the bottom side of the main body. The grip is slid into place and then secured using four M2 screws, firmly fixing it to the main body and completing the structural assembly.

PROGRESS SO FAR...

At this stage, the main blaster assembly is nearly complete. The main body has been assembled with the front section, the front blaster LED board has been mounted in place, the side power-level indicator LED board has been installed, and the internal hand grip has been fitted inside the enclosure.

All that’s left now is wiring and final assembly.

FINAL ASSEMBLY

• Final assembly begins by reconnecting the front blaster PCB, side power indicator board, and push switch wires to the main circuit. Once all connections are verified, the main circuit is carefully placed into its designated slot inside the enclosure, where it slides securely into position.
• Next, the battery is positioned near the handle and secured using hot glue. The audio amplifier module and speaker are also placed in their respective locations and fixed in place with hot glue to prevent movement during use.
• Next, for the user's comfort, a thick foam sheet is added to the inside of the back ring. This foam acts as a cushion, providing support when the blaster is worn. The foam sheet is attached to the inside of the back ring using hot glue.
• Finally, the back ring is aligned and pressure-fitted into place. This step completes the assembly of the Rock Buster.

RESULT

Here’s the end result of this build, a fully working Rock Buster brought to life.

To power the setup, we have added a vertical push button on the main circuit; we press the button, and the whole blaster turns ON.

A push button is mounted directly on the grip, allowing it to be naturally pressed while holding the blaster. When the button is pressed and held, the front blaster begins charging and then fires once released.

The front blaster features a firing effect using a red LED that flickers to simulate a plasma shot, paired with sound effects from the internal speaker to enhance realism. Both the charging and firing behavior change dynamically based on how long the trigger button is held, closely mimicking the mechanics seen in the Mega Man games.

On the side, the power indicator consists of six LED bars that function as an ammo meter. Each time the blaster is fired, one bar is depleted, providing clear visual feedback during use. Once all six bars are consumed, the Rock Buster enters a cooldown mode. During this period, the front blaster, side indicator, and speaker blink red and play alert sounds to indicate temporary shutdown. After the cooldown period ends, the system automatically resets and is ready for use again.

Powered by a Raspberry Pi Pico and a lithium battery, the Rock Buster is fully self-contained and designed to be worn comfortably as a blaster.

Overall, this project was a success, and all related files are attached with this article—feel free to download, modify, and experiment with them. If you have any questions or need help with any part of the project, drop a comment and I’ll be happy to help.

Thanks for reading all the way through. I’ll be back soon with a new project.

PEACE.