LED Riser Pads for Skateboards / Longboards

In this project, we'll 3D print a custom skate truck riser pad and embed NeoPixel LEDs to make headlights! The best part is they're bluetooth connected, so you can change the colors, brightness and even trigger animations all through your smart phone.

Prerequisite Guides

If your new to electronics and the Adafruit Feather Bluefruit, I suggest you walk through the following guides to get basics of wiring and soldering. The Adafruit Feather Bluefruit guide will walk you through setting up Arduino IDE and bluefruit libraries. 

Truck Riser Pads

Truck risers are commonly used on longboards. These provide extra elevation and prevents wheel bite. They're also great for sliding, as they lower a riders center of gravity.

From Wikipedia

Riser pads increase the distance between the wheels on a longboard and the deck in order to prevent wheel bite (when the deck scrapes the wheels, causing the wheels to stop turning). They also reduce the strain on the deck from the trucks being directly in contact with it and the vibration caused through riding. Riser pads are normally made of plastic. Shock pads, which are more rubbery than riser pads, serve the same function only with more emphasis on reducing strain and less on increasing the distance between the wheels and deck. Riser pads also come angled which can make the board turn more or less. Angled risers are usually used by LDP's(Long Distance Pumper) to help aid the rider in pumping (propelling the board with turns)

Integrated NeoPixel LEDs

You can actually get truck risers with built-in LEDs from online retailers. However, they're pretty basic LEDs and come in single colors. The ones I've seen use coin cell batteries and don't offer much functionality. This project uses NeoPixel LEDs which can be programmed to be any color and can even display animations. Combined with an Adafruit Feather Bluefruit, you can change the colors and brightness on the fly using the Adafruit Bluefruit Connect app for iOS/Android

3D Printing

I designed a truck riser pad into an enclosure that houses the electronics using machine screws to minimize vibrations. The part features mounting holes for modern skate trucks.

  • 5.5mm size mounting holes
  • 63.5mm x 41.27mm distance between holes.

The 3D printed parts are printed in strong and durable material like abs, petg, nylon and polycarbonate. The cover and pads can be printed in flexible filament like semiflex ninjaflex (TPU 98A) that will reduce strain and absorb vibrations.


For this project, we're using the Adafruit Feather Bluefruit which is an Arduino compatible that has a bluetooth module. It also has built-in USB power charging circuit. A 500mAh lipo battery for power and an on/off switch. For the headlights, we're using an high-density Adafruit 8x NeoPixel LED stick.

1 x Adafruit Feather nRF52 Bluefruit LE - nRF52832
Bluetooth connected microcontroller
1 x NeoPixel Stick
8 x 5050 RGB LED with Integrated Drivers
1 x 500mAh Battery
Lithium Ion Polymer Battery - 3.7v 500mAh
1 x Slide Switch
Breadboard-friendly SPDT Slide Switch

Tools & Supplies

To put together the electronics, we just need a few tools like a soldering iron and some wire cutters. But using a panavise and helping third just makes things easier. I like using silicone covered wires but you can use whatever you have on hand.

1 x Panavise Jr.
Helps hold onto components while soldering
1 x Solder Iron
Heat pen used for melting solder wire
1 x Helping Third Hand
Helps hold onto wires while soldering
1 x 30AWG Wire
Silicone cover stranded wire
1 x Flush Cutters
Hakko Precision Flat Pliers
1 x Wire Strippers
Hakko Professsional Quality 20-30 AWG Wire Strippers

Hardware Screws

We'll need some machine screws to secure the components to the 3D printed part. This helps minimize vibrations caused from riding. We'll also need to replace the stock hardware for mounting the skate trucks to the board.

Authors Notes:

There's almost no vibrations because all of the components are secured with screws. The battery is set in place using mounting tack, so it works great for absorbing vibrations. There's access to the USB port to reprogram the Adafruit Feather and recharge the battery. It's not water proof so just have to avoid large puddles and rain. The riser pads can be printed in ABS material for a strong and durable part.

3D Printing

Filament & Strong Materials

The main truck riser will house the electronics and battery. I printed it in regular PLA, but it can be printed in ABS or other high-strength material. There's a second riser pad that is meant to be installed on the back set of trucks to "level" out the deck. I print that piece in ABS.

Flexible/Rubber Pads

I printed extra pads in Semiflex Ninjaflex TPU 98A that go in between the trucks and plastic riser enclosure. This will reduce the strain, relieves stress and absorbs any vibrations while riding. These rubber pads aren't crucial to the project but they will most likely prolong the parts durability. 


Houses all of the electronics

no supports, print with PLA, ABS, Nylon, PETG or other.


Snaps ontop of truck riser case.

print with semiflex ninjaflex or TPU 98A.


extra spacer meant to be installed on back trucks to level board.

print in pla, abs or other.


meant to go in between the skate truck and the 3D printed part.

print in semiflex ninjaflex or TPU 98A.

Slice Settings

I sliced the parts using CURA and Simplify3D. Both are great slicers, you'll have to adjust your slice settings in order to properly produce a tool path that is optimized for perimeters. The tolerances may slightly vary from printer to printer. 

Simplify 3D – Flashforge Creator Pro

  • Nozzle Diameter: 0.4mm
  • Extrusion Width: 0.48mm
  • Extrusion Multiplier: 100%
  • Extruder Temp: 220C
  • Infill: 30%
  • Bed: No heat (PrintInZ Build Surface)
  • Default Print Speed: 60mm/s
  • Travel Speed: 90mm/s

CURA – Ultimaker 2+

  • Nozzle Diameter: 0.4mm
  • Line Width: 0.5mm
  • Extruder Temp: 220C
  • Infill: 30%
  • Bed: 65C (Glass surface)
  • Default Printing Speed: 70mm/s
  • Travel Speed: 150mm/s

Semiflex – Ninjaflex (CURA – Ultimaker 3)

  • Nozzle: 0.4mm
  • Extruder 235C
  • Line Width 0.5mm
  • Wall Line count: 2
  • Top/bottom thickness 1.2mm
  • Bed: 60C glass
  • Flow 100% 
  • 2.85mm filament diameter
  • Print Speed 30mm/s
  • Travel Speed 90mm/s
  • Retraction distance: 3mm

No 3D Printer? No Problem! – Try 3D Hubs

If you don't have access to a 3D printer, you can check out 3DHubs.com find a local maker with a 3D printer and have them 3D print and ship the parts to you. Just download the STLs and upload them for quick price quotes. Narrow down your search to a local maker with good reviews and ratings. 

Design Source

I designed the parts in Autodesk Fusion 360 and made the source available to download. It contains full parametric design history so it's easy to remix the design or repurpose it for a new project. 


Adafruit Feather Bluefruit nRF52

Be sure to follow the guide below to install the board and libraries. When you've installed the Bluefruit Arduino profiles and libraries, come back here and continue the tutorial.

Bluetooth App + NeoPixel Color Picker

The Adafruit Feather bluefruit has an on-board Bluetooth Low-Energy module that allows you to connect via the Adafruit Bluefruit Connect iOS/Android App. Using the mobile app, you can choose different colors and brightness to change the NeoPixels on the fly. To get this sketch up and going, you can follow the Bluefruit nRF52 learning guide. There, it will walk you through the installation process.

NeoPixel Demo

For something really quick, I used this sketch to showcase the NeoPixels. This does not feature any special bluetooth control. This sketch is a compilation of animations. It cycles through different sequences that display different colors. It's great for just getting a lot of effects like rainbows, theater chasers and color wipes. This will also work with the Adafruit Feather proto basic if you don't want the extra cost a bluetooth module.

Uploading Sketch to Adafruit Feather Bluefruit

To load the sketch make sure the libraries above are installed, and the Arduino is connected to the computer through a USB cable.  Under the Tools -> Board menu make sure the Adafruit Bluefruit Feather nrf52 is selected, and under the Tools -> Port menu the serial port "/dev/cu.SLAB_USBtoUART" is selected.  

Then press the upload button or click the Sketch -> Upload item to send the code to the Arduino.  Woo-hoo the sketch should be running.

#include <Adafruit_NeoPixel.h>
#ifdef __AVR__
  #include <avr/power.h>

#define PIN 30

Adafruit_NeoPixel strip = Adafruit_NeoPixel(8, PIN, NEO_GRB + NEO_KHZ800);

    uint8_t red = 255;
    uint8_t green = 255;
    uint8_t blue = 255;
    uint8_t animationState = 1;

    int pos = 0, dir = 1; // Position, direction of "eye" for larson scanner animation

void setup() {
  // This is for Trinket 5V 16MHz, you can remove these three lines if you are not using a Trinket
  #if defined (__AVR_ATtiny85__)
    if (F_CPU == 16000000) clock_prescale_set(clock_div_1);
  // End of trinket special code

  strip.show(); // Initialize all pixels to 'off'

void loop() {
  larsonScanner(strip.Color(255,0,0), 60);
  larsonScanner(strip.Color(255,0,20), 60);
  larsonScanner(strip.Color(255,0,40), 60);
  larsonScanner(strip.Color(255,0,60), 60);
  larsonScanner(strip.Color(255,0,70), 60);
  larsonScanner(strip.Color(255,0,80), 60);
  colorWipe(strip.Color(255, 0, 0), 50); // Red
  colorWipe(strip.Color(0, 255, 0), 50); // Green
  colorWipe(strip.Color(0, 0, 255), 50); // Blue
  colorWipe(strip.Color(255, 100, 0), 50); // Organge
  colorWipe(strip.Color(100, 0, 255), 50); //purple
  colorWipe(strip.Color(0, 100, 255), 50); // cyan
  colorWipe(strip.Color(0, 0, 0), 50);
  colorWipe(strip.Color(255, 0, 0), 50);

// 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);

void rainbow(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256; j++) {
    for(i=0; i<strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel((i+j) & 255));

// Slightly different, this makes the rainbow equally distributed throughout
void rainbowCycle(uint8_t wait) {
  uint16_t i, j;

  for(j=0; j<256*5; j++) { // 5 cycles of all colors on wheel
    for(i=0; i< strip.numPixels(); i++) {
      strip.setPixelColor(i, Wheel(((i * 256 / strip.numPixels()) + j) & 255));

//Theatre-style crawling lights.
void theaterChase(uint32_t c, uint8_t wait) {
  for (int j=0; j<4; j++) {  //do 10 cycles of chasing
    for (int q=0; q < 2; q++) {
      for (uint16_t i=0; i < strip.numPixels(); i=i+6) {
        strip.setPixelColor(i+q, c);    //turn every third pixel on


      for (uint16_t i=0; i < strip.numPixels(); i=i+6) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off

//Theatre-style crawling lights with rainbow effect
void theaterChaseRainbow(uint8_t wait) {
  for (int j=0; j < 256; j++) {     // cycle all 256 colors in the wheel
    for (int q=0; q < 6; q++) {
      for (uint16_t i=0; i < strip.numPixels(); i=i+6) {
        strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on


      for (uint16_t i=0; i < strip.numPixels(); i=i+2) {
        strip.setPixelColor(i+q, 0);        //turn every third pixel off

void larsonScanner(uint32_t c, uint8_t wait){
   int j;
 for(uint16_t i=0; i<strip.numPixels()+5; i++) {
  // Draw 5 pixels centered on pos.  setPixelColor() will clip any
  // pixels off the ends of the strip, we don't need to watch for that.
  strip.setPixelColor(pos - 2, 0x100000); // Dark red
  strip.setPixelColor(pos - 1, 0x800000); // Medium red
  strip.setPixelColor(pos , 0xFF3000); // Center pixel is brightest
  strip.setPixelColor(pos + 1, 0x800000); // Medium red
  strip.setPixelColor(pos + 2, 0x100000); // Dark red
  // Rather than being sneaky and erasing just the tail pixel,
  // it's easier to erase it all and draw a new one next time.
  for(j=-2; j<= 2; j++) strip.setPixelColor(pos+j, 0);
  // Bounce off ends of strip
  pos += dir;
  if(pos < 0) {
    pos = 1;
    dir = -dir;
  } else if(pos >= strip.numPixels()) {
    pos = strip.numPixels() - 2;
    dir = -dir;
 //colorWipe(pixel.Color(0, 0, 0), 20);

// 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) {
  WheelPos = 255 - WheelPos;
  if(WheelPos < 85) {
    return strip.Color(255 - WheelPos * 3, 0, WheelPos * 3);
  if(WheelPos < 170) {
    WheelPos -= 85;
    return strip.Color(0, WheelPos * 3, 255 - WheelPos * 3);
  WheelPos -= 170;
  return strip.Color(WheelPos * 3, 255 - WheelPos * 3, 0);

Circuit Diagram

Circuit Diagram

This provides a visual reference for the wiring of the components. They aren't true to scale, just meant to be used as reference. The switch and NeoPixel stick will share the same ground pin on the Adafruit Feather. Although NeoPixels normally require 5V, we'll need to connect it to the 3V pin on Feather for the ability to turn power off via the Enable pin.

To power this circuit, we'll use a 3.7v 500mAh lipo battery. The feather has an on board regulator that will convert the voltage automatically. The Adafruit Feather has an on-board charging circuit, so we can recharge it over USB when the battery gets low.

  • Data In from NeoPixel to Pin 30 on Feather
  • Ground from NeoPixel to ground on Feather
  • 5V from NeoPixel to 3V on Feather
  • Switch to ground and enable pin on Feather
  • Battery to JST connector on Feather

Slide Switch

Slide Switch

First thing we'll do is connect the slide switch to the Adafruit Feather. We'll need to connect two wires to the switch. These wires will connect to the enable and ground pins on the Adafruit Feather. 

I started by removing one of the three electrodes from the slide switch, either the far left or right, but not the middle. Then, cut the remaining two electrodes in half.


Tin Switch

Secure the slide switch to a pair of helping third hands. Tin the two shortened electrodes by applying a small amount of solder to each. Tinning the electrodes will make it much easier to attach wires to them.

Switch Wires

Now we can measure two pieces of wire, each 5cm in length, and cut them down to size. These will need to be soldered to the two electrodes on the switch. Use wire strippers to remove a bit of insulation from the tips of each wire. Secure the two wires to third helping hands. Tin the exposed tips of the wires by adding a small amount of solder to them. 

Switch Wiring

Now we can attach the wires to the electrodes on the slide switch. Secure the switch on to helping third hands. Using the tip of the soldering iron, heat up the electrodes on the switch and slowly bring a wire close to the electrode. Once solder attaches, retract the tip of the soldering iron and let solder solidify for 2-3 seconds. Repeat process for the second wire. 

Connect Switch to Feather

Secure the Adafruit Feather to Panavise. Tin the ground and enable pins with a small amount of solder. Then, using the tip of the soldering iron, heat up the pin and slowly insert one of the wires from the switch. Repeat process for enable and ground pins.

Test Switch with Battery

Remove the Adafruit Feather from the Panavise. Connect the battery to the Feather by plugging in the JST connector from the battery to the female JST connector on the Adafruit Feather. Use the slide switch to power the circuit on and off. 


NeoPixel Wires

We'll need three wires to connect the NeoPixel stick to the Adafruit Feather. I suggest using three different colored wires to help tell the connections apart. The wires will need to be 13cm in length. Use wire cutters to cut three pieces of wire down to size. 

Tin NeoPixel Wires

Use wire strippers to remove a small amount of insulation for each of the three wires. Secure the wire to helping third hands. Tin the exposed tips of each wire by applying a small amount of solder. Use the tip of the soldering iron to heat up the exposed tip, then bring the solder wire close until it melts on the strands of wire. This will help prevent the strands of wire from fraying and makes it easier to attach them to the NeoPixels.

Tin NeoPixel 

Next, we'll work on attaching the wires to the pads on the NeoPixel stick PCB. On the back, are two sets of 4 pads. Look for the pad with the label "DIN" (That stands for "Data-Input"). We'll need to tin three pads with a bit of solder. Apply a small amount of solder up to the 5VDC, GND and DIN pads. 

Solder Wires to NeoPixel

Secure the NeoPixel PCB to third helping hands. Orient the PCB so that the wires can be soldered in-line with the NeoPixels. Heat one of the tinned pads with soldering iron tip and lay a corresponding wire onto the pad while the solder is molten. Lift tip and let dry. Repeat for the DIN, 5VDC and GND pads.

Feather to NeoPixel

Now we can connect the NeoPixel stick to the Adafruit Feather. We'll need to start by securing the Adafruit Feather PCB to the Panavise. To keep the three wires grouped together, you can use a piece of heat shrink tubing. Cut a small piece from the tube and slide the wires through. Using a lighter or heating element (not the tip!) of the soldering iron, apply heat to the tube and watch it shrink like magic.

Connect NeoPixel Wires to Feather

Apply a bit of soldering to pin #30, G, and 3V on the Adafruit Feather. Then, connect the DIN wire from the NeoPixel to pin #30 on Adafruit Feather. Connect GND from NeoPixel to G on Adafruit Feather. Then, 5VDC from NeoPixel to 3V on Adafruit Feather.

Share Ground

You will need to share the G (ground) pin on the Adafruit Feather with the ground wire from NeoPixel and the switch.

Finished Circuit

And now we have our final circuit! We're done with all the wiring, we can now work on mounting the components to the 3D print. Double check your work and ensure all of the connections look solid.

Test Circuit

Now is a good time to test the circuit! If you've uploaded any code to the Adafruit Feather, you can connect the battery and engage the switch to power it on. You'll need to conduct your own testing, depending on the sketch your running. In this example, I'm testing out the bluefruit control using the Adafruit Bluefruit Connect iOS app for iPhone and the NeoPixel Picker arduino sketch (the one included with the bluefruit nRF52 library).

Install Electronics

Secure Components

Now that we've wired and tested our circuit, it's time to mount everything to the 3D printed truck riser pad. Get your screwdriver and hardware together! Take a moment to see where all the components will go and see if our wires are long enough to fit everything in place. 

Install NeoPixel Stick

The NeoPixel stick will be mounted vertically on the two mounting holes located near the front side of the truck riser. Insert and place the NeoPixel stick PCB on top of the mount and line up the holes. 

Installing NeoPixel Wires

The three wires connected to the NeoPixel PCB will need to be positioned underneath the right mounting hole. Use your fingers to push the wires below so the PCB can be mounted flush with the mounting holes. Route the wires so they go in between the opening.

Mount NeoPixel

With the NeoPixel stick held in place, drive an M2.5-10mm machine screw through one of the mounting holes. Use a screwdriver to fasten the screw until the protudes the other side. Then, place an M2.5 hex nut into the screw. Fasten until fully tightened. Repeat this process for the second mounting hole.

Mount Adafruit Feather

Position the Adafruit Feather PCB over the four standoffs. Orient the board so the microUSB port is facing the side of the truck riser with a cut out. Line up the mounting holes with the holes in the stands offs. Insert and fasten M2.5-5mm machine screws from the top of the board and drive through the mounting holes until secured in place. Repeat process for all four mounting holes.

Mount Battery

Next we'll secure the 500mAh lipo battery to the truck riser pad. In the center, next to the Adafruit Feather, are walls that will hold the battery in place. I suggest adding pieces of mounting tack in between the battery and the truck riser. This will help minimize the vibrations and keep the battery attached to the surface of the part.

Mount Switch

Now it's time to mount the slide switch. Near the side of the Adafruit Feather are three smaller walls, these will keep the slide switch held in place. You'll need to insert the slide switch at an angle in order to pop it into place. If the switch doesn't have a tight fit, you'll need to use hot glue or E6000 adhesive to permanently secure it in place.

Mounted Components

And now we have all of the electronics secured in place! All we have to do now is install the truck riser in between the deck and the trucks. w00t!

Install Truck Riser

Install Cover

The 3D printed cover can be installed on top of the truck riser. This will protect the electronics and reduce stress from the trucks. It has an inner lip that slides into the walls of the truck riser. Press the cover until it's fully flush with the part.

Install Truck Riser

Now we're ready to install the NeoPixel Truck Riser! Place the truck riser with the cover facing the bottom of the board. Orient the part so the mounting holes all line up. Place the skate truck over the 3D printed riser and line up the mounting holes. Insert and drive four #10-32 x 2" long machine screws through the board, riser and trucks. Insert a #10 hex lock nut into each screw and fasten until fully tightened. You can use a screwdriver to hold the screw in place while turning a socket wrench to tightened the hex nut. 

NeoPixel Truck Riser

And now we have our final assembly complete. Now we're ready for a test drive! When the battery gets low, you can plug in a USB cable to the microUSB port on the Adafruit Feather and recharge.