The Beetles PCB ART

Greetings everyone, and welcome back.

This is Let It Glow, a Beatles-themed PCB art board that plays Beatles songs and lights up with RGB LEDs across a custom-designed front panel.

The top PCB features a cartoon-style image of the original Beatles, inspired by their animated TV show from the 1960s. I found the artwork on Pinterest, converted it into a PCB design, and layered it over a baseboard packed with electronics powered by a Raspberry Pi Pico 2 and a DFPlayer Mini.

Using my electronics skills, I turned the whole idea into a glowing, music-playing tribute. It’s not just a lamp or just a music player; it’s a fusion of ideas: a custom LED-lit music box, a visual homage, and a piece of electric art.

I’m not even sure what to call this device for now; I’m going with Let It Glow.

Drop your name suggestions in the comments.

This Article features the whole build process of this project, so let's get started with the project.

Materials Required

These were the materials used in this project:

• Custom PCBs
• Raspberry Pi PICO 2
• WS2812B RGB LEDs
• DF MINI PLAYER
• SD CARD
• IP5306
• 10 uF 1206 Capacitors
• 100 nF 0603 Capacitors
• Type C Port
• SMD Indicator LED 0805 Package
• Push Buttons 4x4
• Li-ion Cell
• 3D-printed parts
• M2.5 Screws
• M2.5 PCB standoffs

PCB ART

I’ve always loved art, especially painting. So when I started learning electronics, I was instantly intrigued by how makers were turning PCBs into visual canvases. Logos, illustrations, and patterns are all etched into the solder mask and silkscreen layers. That’s when I knew I had to try it myself.

My journey into PCB art began with a Flux Capacitor board, where I used LEDs to recreate the iconic flux capacitor design from Back to the Future. That project gained attention on Hackaday and other maker platforms, and it sparked a whole series of creative builds.

Next came Pandacorn, which was a panda with a unicorn horn. I placed all the SMD components and LEDs on the bottom side of the board and designed the panda illustration on the top. The horn area had the solder mask removed from both layers, allowing light from the flipped LEDs to shine directly through the board. I first saw this clever trick in a Hackaday SAO badge, and it opened up a whole new way of thinking about PCB layering.

Since then, I’ve created multiple themed boards inspired by Halo, Attack on Titan, heart-shaped badges, R2-D2, and more. You can check them all out on my Hackster page.

For the Beatles-inspired art board, my approach was simple but intentional. I searched for a cartoon-style design of the original Beatles that I could replicate on a PCB. Then I used solder mask openings on both the top and bottom layers to control how light passes through. RGB LEDs mounted on the lower PCB shine upward, illuminating the artwork from behind. The result is a glowing tribute where electronics and illustration merge into one expressive piece.

This is what PCB art means to me: turning circuits into stories and solder mask into brushstrokes.

DESIGN

Before starting the PCB design, I first created a 3D model in Fusion 360.

For projects like this, a 3D Model is super crucial, as it allows you to finalize the size and placement of major components, which affects the PCB layout. Precise dimensions and positioning are essential when working with tight tolerances and layered boards.

In this build, the speaker plays a central role. It not only needs to be supported securely within the enclosure but also positioned to enhance sound quality. That’s why designing the enclosure early was key; it helped shape both the mechanical and acoustic aspects of the project.

Once the model was complete, I created an enclosure that houses both the speaker and the lithium cell. The mesh file was exported and 3D printed using my new Anycubic Kobra S1 — giving the project a clean, custom-fitted shell that ties the whole build together.

PCB DESIGN

Next comes the most important section of this project, the PCB design process, which involves two separate PCBs: the Front Art Layer and the Main Board that holds all the electronics.

We begin with the Main Board by creating a simple schematic that includes the Raspberry Pi Pico connected to the DFPlayer Mini and a CON5 header pin. This header connects GPIO12, GPIO13, and GPIO15 along with GND from the Pico. These three GPIOs are used as button inputs for next track, volume up, and volume down functions.

The DFPlayer Mini is connected to GPIO7 and GPIO8 of the Pico, which serve as its TX and RX pins.

For the lighting effect, we use 24 WS2812B RGB LEDs connected in series to form a continuous chain. The DIN of the first LED is connected to GPIO0 of the Pico, with VCC connected to 5V and GND to ground. Each LED has its own decoupling capacitor placed as close as possible between its VCC and GND pins.

For power, we’ve included our trusted IP5306 — a power management IC we’ve used in many previous projects. It provides a stable 5V output from a 3.7V lithium cell and includes features like charging indication, low battery warning, and high/low voltage cutoffs, all essential for safe lithium cell operation.

For the Front Art Layer, we took the image found on Pinterest, scaled it to match the PCB dimensions defined in the 3D model, and converted it from JPG to a monochrome BMP format. This allowed us to import it into the PCB CAD tool as a logo.

We applied copper etching to all black areas in the image, while the white regions were left as solder mask openings. The same solder mask openings were added to the bottom layer as well. The idea was to use the etched areas to block light and the solder mask openings to let the RGB glow pass through.

After finalizing both designs, we exported the Gerber files and sent them for PCB manufacturing.

NextPCB PCB Service

After completing the PCB Design, Gerber Data was sent to HQ NextPCB, and two orders were placed, one for a Black soldermask and other for Green 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.

MAIN BOARD ASSEMBLY PROCESS

• We begin assembling the main board by applying solder paste to each SMD pad using a dispensing needle. For this build, we’re using 63/37 Sn/Pb solder paste, which has a melting point of around 200°C.
• Next comes the pick-and-place stage, where each surface-mount component, which includes RGB LEDs, the IP5306 power management IC, capacitors, and resistors, are carefully positioned using ESD-safe tweezers.
• Once all components are in place, the PCB is transferred to a reflow hotplate. The board is heated from below until it reaches the solder paste’s melting temperature. At that point, the solder melts and solidifies, locking all SMD components securely in place.
• With the surface-mount process complete, we move on to the through-hole components. Female header pins for the Raspberry Pi Pico and DFPlayer Mini, a USB Type-C port, male header pins, and an inductor are added from the top side of the board.
• The PCB is then flipped, and all through-hole pads are soldered manually using a soldering iron to ensure strong mechanical and electrical connections.
• Finally, the Raspberry Pi Pico and DFPlayer Mini are mounted onto their respective headers, marking the completion of the assembly process.

TEST CODE for WS2812B LEDs

After completing the PCB assembly process, the next step was to test whether the SMD RGB LEDs were functioning properly. To do this, we flashed the Raspberry Pi Pico 2 with a demo sketch from the Adafruit NeoPixel library, one of the example codes provided with the library.

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
#include <avr/power.h>
#endif
#define PIN        0
#define NUMPIXELS 25 // Popular NeoPixel ring size
Adafruit_NeoPixel pixels(NUMPIXELS, PIN, NEO_GRB + NEO_KHZ800);
#define DELAYVAL 100
void setup() {
#if defined(__AVR_ATtiny85__) && (F_CPU == 16000000)
clock_prescale_set(clock_div_1);
#endif
pixels.begin();
}
void loop() {
pixels.clear();
for(int i=0; i<NUMPIXELS; i++) { // For each pixel...
pixels.setPixelColor(i, pixels.Color(0, 150, 0));
pixels.show();   // Send the updated pixel colors to the hardware.
delay(DELAYVAL); // Pause before next pass through loop
}
}

This quick test helped verify the LED wiring, data line integrity, and power delivery across the board. Seeing the first glow confirmed that the PCB layout and soldering were solid

ART LAYER ASSEMBLY PROCESS

The front board contains four through-hole 4×4 tactile push buttons. Each button is placed carefully into its designated position on the PCB. Once aligned, the board is flipped over and all the pads are soldered securely, locking the buttons in place.

SPEAKER ASSEMBLY

Next comes the speaker assembly process. It begins by soldering the speaker’s positive terminal to the Speaker 1 pin on the DFPlayer Mini, while the Speaker ground (GND) terminal is connected to the Speaker 2 terminal of DFplayer.

This simple wiring setup completes the audio path.

POWER SOURCE

The original plan was to use a standard 18650 Li-ion cell but ended up using a 14500 lithium cell. It offers the same operating voltage of 3.7V but with a smaller form factor and approximately half the capacity — around 600mAh.

The positive and negative terminals of the 14500 cell were soldered directly to the board’s battery connector using a soldering iron, completing the power circuit.

MAIN CODE

Here's the main code we used in this project and it's a simple one; let me explain.

#include <SoftwareSerial.h>
#include <DFRobotDFPlayerMini.h>
#include <Adafruit_NeoPixel.h>
SoftwareSerial mySerial(7, 8); // RX, TX
DFRobotDFPlayerMini myDFPlayer;
const int totalSongs = 4;
int currentSong = 1;
int currentVolume = 20;
// Button pins
const int nextPin = 12;
const int volUpPin = 13;
const int volDownPin = 14;
// LED setup
#define LED_PIN     0
#define LED_COUNT   24
Adafruit_NeoPixel strip(LED_COUNT, LED_PIN, NEO_GRB + NEO_KHZ800);
void setup() {
Serial.begin(9600);
mySerial.begin(9600);
pinMode(nextPin, INPUT_PULLUP);
pinMode(volUpPin, INPUT_PULLUP);
pinMode(volDownPin, INPUT_PULLUP);
strip.begin();
strip.show();
if (!myDFPlayer.begin(mySerial)) {
Serial.println("DFPlayer Mini not found");
while (true);
}
myDFPlayer.volume(currentVolume);
delay(1000);
myDFPlayer.play(currentSong);
updateLEDs();
}
void loop() {
if (myDFPlayer.available()) {
uint8_t type = myDFPlayer.readType();
if (type == DFPlayerPlayFinished) {
currentSong++;
if (currentSong > totalSongs) currentSong = 1;
myDFPlayer.play(currentSong);
}
}
// ⏳ Press-and-hold logic for next song
static unsigned long nextPressStart = 0;
if (digitalRead(nextPin) == LOW) {
if (nextPressStart == 0) nextPressStart = millis();
if (millis() - nextPressStart >= 1000) {
currentSong++;
if (currentSong > totalSongs) currentSong = 1;
myDFPlayer.play(currentSong);
nextPressStart = 0;
while (digitalRead(nextPin) == LOW); // Wait for release
}
} else {
nextPressStart = 0;
}
// Volume Up
if (digitalRead(volUpPin) == LOW) {
delay(200);
if (currentVolume < 30) currentVolume++;
myDFPlayer.volume(currentVolume);
while (digitalRead(volUpPin) == LOW);
}
// Volume Down
if (digitalRead(volDownPin) == LOW) {
delay(200);
if (currentVolume > 0) currentVolume--;
myDFPlayer.volume(currentVolume);
while (digitalRead(volDownPin) == LOW);
}
}
void updateLEDs() {
for (int i = 0; i < LED_COUNT; i++) {
if (i < 6) {
strip.setPixelColor(i, strip.Color(255, 255, 0)); // Yellow
} else if (i < 12) {
strip.setPixelColor(i, strip.Color(255, 0, 128)); // Pink-purple mix
} else if (i < 18) {
strip.setPixelColor(i, strip.Color(0, 255, 255)); // Cyan-blue
} else {
strip.setPixelColor(i, strip.Color(0, 255, 0)); // Light green
}
}
strip.show();
}

In our Setup we have used three key libraries:

•SoftwareSerial for serial communication

•DFRobotDFPlayerMini to control the DFPlayer audio module

• Adafruit Neopixel to drive the RGB LEDs

The setup includes four buttons: one for skipping tracks (press-and-hold), one for volume up, one for volume down, and one for power. When a button is pressed, the device responds accordingly changing the song, adjusting the volume, or triggering LED behavior.

The RGB LEDs glow continuously, split into four color zones: yellow, pink-purple, cyan-blue, and light green, each mapped to a section of the front PCB. The code also handles automatic track progression when a song finishes.

FINAL ASSEMBLY

• To connect the main PCB with the front PCB, we use a custom-built CON5 header, a makeshift connector made by soldering a male header pin directly to a female header pin. This hybrid setup plugs into the male CON5 connector on the main board, creating a reliable link between the two PCBs.
• Next, we install four M2.5 PCB standoffs into the mounting holes of the front PCB. With the header connector and standoffs aligned, we carefully sandwich the front PCB onto the main board, locking the two layers together both electrically and mechanically.
• We then move to the enclosure. A 3D-printed shell houses the speaker and lithium cell, which are placed securely in their designated slots. The entire enclosure assembly is positioned behind the main PCB, and four M2. 5 screws are used to fasten everything together—completing the build.
• At this point, the device is fully assembled.

RESULT

Here’s the end result of this simple yet fun build-a Beatles-themed art-light music player that’s hard to categorize. It plays a selection of Beatles songs stored on an onboard SD card and features a custom front panel with cartoon-style illustrations of the four original Beatles members.

The panel glows in four distinct colors, each mapped to a zone of RGB LEDs beneath the artwork, giving the device a vibrant, aesthetic feel. It’s designed to rest on my desk, right beside my monitor, but I also added a hook so it can hang on a wall using a nail.

It’s not just a music player. Not just a lamp.

It’s a fusion of sound, light, and illustration a personal tribute built from electronics combined with ART.

Thanks for reaching this far, and I will be back with a new project soon.