Introduction: Youtube Play Button- Electronics Edition

By
About: Hello world;

Hey everyone, welcome back.

A customized PCB in the form of a YouTube icon that is equipped with RGB LEDs and controlled by an ESP12F module is used in this unique project.

The idea behind this project was to create a light-up YouTube play button logo that I could display on a shelf as a joke about the possibility of a genuine play button replacing this one in the future.

The WS2811 IC, an addressable RGB LED controller IC, is used to connect the 22 normal RGB LEDs on this board, which is manufactured entirely of PCB.

All of these LEDs are being driven by an SMD ESP8266-based DEV board called the ESP12F module.

This is a simple project to make, so let me show you guys how it was built,

Let's get started.

Supplies

The following materials were used in this project-

  • Custom PCB
  • ESP12F Module
  • Nodemcu board
  • RGB LED SMD 5050 Package
  • WS2811 IC
  • AMS1117 3.3V
  • 10uF 1206 Capacitor
  • 1uF 1206 Capacitor
  • 10K Resistor 0805 Package

Step 1: PCB Design

We begin by creating the schematic, which consists of an ESP12F Minimal Setup coupled with a WS2811 IC that manages 22 RGB LEDs that are all wired in parallel. An AMS1117 3.3V Version is also included in the setup to provide voltage stepping down from the 5V USB in to power the ESP12F module, which operates at 3.3 Volts.

After the schematic is complete, we create the board layout by first searching for a black-and-white image of a YouTube icon on the internet. I then imported this image into the PCB design software and placed all of the LEDs around its perimeter, the ESP12F on one side, and the remaining components on the other.

Step 2: PCBWAY Service

After placing everything and finalizing the board, I send its Gerber data to PCBWAY for samples.

I used PCBWAY PCB Service for this project. I uploaded the Gerber file for this project on PCBWAY's quote page. I used a red Soldermask and a white silkscreen for this YouTube Play Button.

After placing the order, I received the PCBs within a week, and the PCB quality was pretty great. The silkscreen I used is completely random and asymmetrical, so it's pretty hard to make, but they did an awesome job of making this PCB with no errors whatsoever.

You guys can check out PCBWAY If you want Great PCB Service at an Affordable rate and low price.

Step 3: PCB Assembly

  • Board Assembly Process begins by first adding solder paste to each component pad one by one.
  • Next, using a tweezer, we pick and position each SMD component in its designated location. we first begin with adding RGB LEDs and WS2811 IC, then we add ESP12F with AMS1117 setup.
  • Following that, we carefully lifted the entire circuit board and set it down on the SMT Hotplate, which heats the PCB from below up to the solder paste melting temperature. As soon as the PCB reaches that temperature, the solder paste melts, and all the components are connected to their pads.
  • PCB is now fully assembled.

Step 4: Edited Done in PCB

I made a mistake on this board.

It appears that the ESP12F Module only has 12 PWM pins, yet IO15, a pin that isn't a PWM pin, is connected to the WS2811 IC Din Port.

Therefore, I had to remove the track that connects IO15 to the Din Port of the WS2811 and put a jumper between Din Pin and IO14 Pin, a PWM Pin.

Step 5: Programming the ESP8266 With Nodemcu

For programming this board, we could use two methods.

1. Use an FTDI UART Board with Boot Mode Buttons

2. Use a NODEMCU Board without adding any Boot Mode Button

The method that involves programming the board with NODEMCU is the best way to program any ESP device or chip.

Nodemcu has an onboard CP2102 chip, which is a UART chip for programming the MCU through TX and RX pins.

Nodemcu also has two transistors that put the ESP into boot mode, which terminates the manual process of adding external buttons and pressing them during the uploading process.

Previously, I made a programmer board that broke out these pins from the NODEMCU board.

  • 3v
  • GND
  • RST
  • GPIO0
  • TX
  • RX

Before the main wiring, we add a jumper between the ENABLE pin of the nodemcu and GND. This will put the ESP8266 board of NODEMCU to sleep, and we can connect an external ESP8266 board with the onboard CP2102 chip.

We connect the ESP12F's 3V, GND, RST, GPIO0, TX, and RX pins with the same pins of the nodemcu.

  • First, we connect the nodemcu Board's header pins to the ESP12F pins in the right order.

  • Next, we open Arduino IDE and plug the USB into nodemcu.
  • we then go to the Tools menu and select the board that is being used which is in this case NODEMCU1.0 board.
  • we select the right com port and hit upload.


Step 6: Code and Library Needed

Here's the code that is being used in this project.

It uses Adafruit's NeoPixel Library, which you need to install first before using this sketch.

https://github.com/adafruit/Adafruit_NeoPixel

#include <Adafruit_NeoPixel.h>
//Hacked from the original Adafruit library demo

#define PIN 12  //my control pin

// Parameter 1 = number of pixels in strip
// Parameter 2 = pin number (most are valid)
// Parameter 3 = pixel type flags, add together as needed:
//   NEO_KHZ800  800 KHz bitstream (most NeoPixel products w/WS2812 LEDs)
//   NEO_KHZ400  400 KHz (classic 'v1' (not v2) FLORA pixels, WS2811 drivers)
//   NEO_GRB     Pixels are wired for GRB bitstream (most NeoPixel products)
//   NEO_RGB     Pixels are wired for RGB bitstream (v1 FLORA pixels, not v2)
Adafruit_NeoPixel strip = Adafruit_NeoPixel(1, PIN, NEO_GRB + NEO_KHZ800);



void setup() {
  strip.begin();
  strip.show(); // Initialize all pixels to 'off'
}

void loop() {
  //Start out with a purple color
  colorWipe(strip.Color(102, 0, 102), 1); // purple

  //Throb read and then fade out
  PlasmaPulse(100);
}

// Fill the dots one after the other with a color
void colorWipe(uint32_t c, uint8_t wait) {
  for(uint16_t i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, c);
      strip.show();
      delay(wait);
  }
}

void PlasmaPulse(uint8_t wait) {
  uint16_t i, j;
  uint8_t brightness = 255;

  for(i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 255, 255));
  }
  strip.show();
  delay(wait);
  //Adjust 60 and 90 to the starting and ending colors you want to fade between. 
  for(j=170; j>=135; --j) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    brightness -= 6;
    strip.setBrightness(brightness);
    delay(wait);
  }

  for(j=135; j<1170; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));
    }
    strip.show();
    brightness += 6;
    strip.setBrightness(brightness);
    delay(wait);
  }

  for(i=0; i<strip.numPixels(); i++) {
    strip.setPixelColor(i, strip.Color(255, 255, 255));
  }
  strip.show();
  delay(wait);

}

// Input a value 0 to 255 to get a color value.
// The colours are a transition r - g - b - back to r.
uint32_t Wheel(byte WheelPos) {
  if(WheelPos < 85) {
   return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);
  } else if(WheelPos < 170) {
   WheelPos -= 85;
   return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  } else {
   WheelPos -= 170;
   return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  }
}

Step 7: Adding USB Port

Finally, we solder a THT Micro USB port onto this board.

By plugging in any 5V source, such as a charger or a power bank, we can power this board and make it glow.

Step 8: END Result

Here is the finished product of this build: a glowing, functional YouTube play button. It differs significantly from the current Creators Award, but that's good as long as it functions.

It's kind of necessary to mount this somewhere in order to finish this project, so I drilled three holes in my shelf and added the PCB to it using three M2 screws.

The project is finally finished when we draw a rectangle frame around the PCB to create a layout that resembles a play button plaque.

Because of the RGB LEDs and aesthetics, it looks really goofy and extremely magnificent at the same time.

Step 9: Conclusion

This project was successful; however, a few issues need to be fixed, including the LED pin and a small change to the code because it has an ESP8266 board that allows us to add any IOT sketch, such as a glowing notification device.

I hope a real plaque will eventually take the place of this setup; we'll see.

This is it for today folks, I hope this project was fun. leave a comment if you need any info or help regarding this project.

and I'll be back with a new project pretty soon.

Peace out.