Here’s how to build a fretless guitar powered by a Particle Argon

Take your guitar and turn it up to 11 with this Particle Argon-powered, fretless guitar build.

Hirotaka Niisato article author avatarHirotaka NiisatoMarch 20, 2019
Here’s how to build a fretless guitar powered by a Particle Argon
Editor’s note: Most guitar players rely on frets to help them consistently play notes. Frets are easy to spot on your average guitar since they are the metal strips that span the width of the guitar’s fingerboard. But you won’t find any frets on the guitar pictured in this project. That’s because some musicians prefer their guitars without frets because they feel they can produce a wider range of sound sans frets.

Hirotaka Niisatom is one such musician. He combined his passion for fretless playing with his love of electronics projects. The result is something to behold: a Particle Argon-powered fretless guitar with colorful Neopixel LEDs.

This post originally appeared on Hackster and is republished with the author’s permission.

What you’ll need

  • Particle Argon
  • Guitar
  • WS2812B aka Neopixel (x10)
  • Inertial measurement unit (IMU) with 6° of freedom
  • 3.7V 1200 mAh LiPo battery
  • Titebond or a similar adhesive
  • Drill
  • Sand paper (120 & 240 grit)
  • 5mm acrylic rod
  • Epoxy resin

This project hacks a normal guitar so you can control NeoPixel LEDs with it. Particle Argon in back side of pick guard control the NeoPIxel LED. You could control the LED color pattern when your play the guitar with MPU 6050 6-axis sensor in guitar.

And I want to make and play a fretless guitar, so this guitar don’t have a frets. Fretless guitar sound is very unique and interesting.

1. Teardown the guitar

First of all, let’s tear down the guitar. I use stratocaster type guitar (I got a this second hard guitar about $25).

2. Make the fretless fingerboard

I really want to play the fretless guitar, then I removed the all fret from guitar by using pliers. When this process, it’s careful not to damage to the fingerboard.

Next, fill the epoxy resin to fret gap. Attach the masking tape to the neck for don’t be sticked the epoxy. Leave the neck about 24 hours, then remove the epoxy resin with sand paper.

3. Set an LED to position marker on fingerboard

Next, separate neck and fingerboard for set the NeoPixel LED. Fingerboard and neck is bonded by wood glue. Place a cloth on the fingerboard, heat the fingerboard by using Steam Iron for melt the glue, it’s important a lot of steam in this process. Little by little, separate the neck and fingerboard with metal spatula.

Next step make a position marker hole to fingerboard with drill.

I think it’s better to set a NeoPixel LED to back side of fingerboard, so I extended a position marker hole (back side of fingerboard) with chisel for fitting to a NeoPixel LED size just a little.

The wiring of the NeoPixel LED passes through the neck truss rod groove, but 12 fret position marker don’t have a groove. Then make the groove vertically on 12 fret position for LED wiring.

Finally set the Neopixel LED to position marker hole and wiring with powerful double-sided tape. It’s good fo put insulation tape on truss rod. NeoPixel LED will be crimped by fingerboard and neck.

Before crimp the fingerboard and neck, make a position marker by using Acrylic rod(5mm). And test a neo pixel LED light.

All LED works fine, crimp the fingerboard and neck with Titebond. Leave it for 24 hours.

After 24 hours, test the nexopixel LED light works fine.

Next paint epoxy resin to fingerboard. This is done for three reasons:

  • (1) to protect fingerboard for damaged by fretless guitar strings;
  • (2) to protect the position marker LED;
  • (3) and, to provide a smooth surface for my fingers to slide across while I play the fretless guitar.
  • After painting the epoxy resin, leave it for 24 hours and brush the fingerboard with sandpaper. Here is NeoPixel LED output wiring from neck.

    Make the hole with drill to the guitar body for NeoPixel LED wiring.

    Joint the neck and guitar body, check the NeoPixel LED light.

    4. Make the Particle Argon place

    I use Particle Argon&LiPo battery for NeoPixel LED control. Don’t you think it’s interesting the guitar will be MESH Thread(IPv6/Bluetooth) gateway? Then I made the place with chisel on guitar body for Particle Argon. And paint the epoxy resin to the that place.

    Set the Particle Argon and MPU-6050 on the guitar body. Argon LiPo power line passes through to the spring cavity unit by using ground connection hole from volume knob.

    LiPo battery is set with sticky back fastener on the guitar body. If it need to change the LiPo battery, it’ easy to replace.

    LED guitar is finish.

    Here is Argon MPU-6050 control LED guitar sample source code.

    #include <MPU6050.h>
    #include "Particle.h"
    #include "neopixel.h"
    #define PIXEL_PIN D2
    #define PIXEL_COUNT 10
    #define PIXEL_TYPE WS2812B
    Adafruit_NeoPixel strip(PIXEL_COUNT, PIXEL_PIN, PIXEL_TYPE);
    MPU6050 accelgyro;
    int16_t ax, ay, az;
    int16_t gx, gy, gz;
    int rval = 0;
    int gval = 0;
    int bval = 0;
    // Prototypes for local build, ok to leave in for Build IDE
    void rainbow(uint8_t wait);
    uint32_t Wheel(byte WheelPos);
    int counter = 0;
    bool remoteColor;
    bool success = Particle.function("color", color);
    int color(String extra) {
        if (!remoteColor) {
            remoteColor = true;
            if (extra.equals("RED"))
                colorWipe(strip.Color(255, 0, 0), 50);
            else if (extra.equals("GREEN"))
                colorWipe(strip.Color(0, 255, 0), 50);
            else if (extra.equals("BLUE"))
                colorWipe(strip.Color(0, 0, 255), 50);
            else if (extra.equals("RAINBOW"))
            else if (extra.equals("RAINBOWCYLE"))
            else if (extra.equals("THEATERCHASE"))
            remoteColor = false;
        return 0;
    void setup() {
        remoteColor = false;
    void loop() {
        if (!remoteColor) {
            int16_t tmp_ax, tmp_ay, tmp_az;
            int16_t tmp_gx, tmp_gy, tmp_gz;
            int16_t diff_ax, diff_ay, diff_az;
            int16_t diff_gx, diff_gy, diff_gz;
            accelgyro.getMotion6(&tmp_ax, &tmp_ay, &tmp_az, &tmp_gx, &tmp_gy, &tmp_gz);
            diff_ax = tmp_ax - ax; diff_ay = tmp_ay - ay; diff_az  = tmp_az - az;
            diff_gx = tmp_gx - gx; diff_gy = tmp_gy - gy; diff_gz  = tmp_gz - gz;
            ax = tmp_ax; ay = tmp_ay; az = tmp_az;
            gx = tmp_gx; gy = tmp_gy; gz = tmp_gz;
            int tmp_rval = map(abs(diff_ax), 0, 0xFFFF/8, 0, 255);
            int tmp_gval = map(abs(diff_ay), 0, 0xFFFF/8, 0, 255);
            int tmp_bval = map(abs(diff_az), 0, 0xFFFF/8, 0, 255);
            if (tmp_rval > 255) tmp_rval = 255;
            if (tmp_gval > 255) tmp_gval = 255;
            if (tmp_bval > 255) tmp_bval = 255;
            rval = (tmp_rval + rval) / 2;
            gval = (tmp_gval + gval) / 2;
            bval = (tmp_bval + bval) / 2;
            Serial.print(rval);  Serial.print("\t");
            Serial.print(gval);  Serial.print("\t");
            Serial.print(bval);  Serial.print("\t");
            for(int i = 0; i < strip.numPixels(); i++) {
                strip.setPixelColor(i, strip.Color(rval, gval, bval));
    // 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<10; j++) {  //do 10 cycles of chasing
        for (int q=0; q < 3; q++) {
          for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
            strip.setPixelColor(i+q, c);    //turn every third pixel on
          for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
            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 < 3; q++) {
          for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
            strip.setPixelColor(i+q, Wheel( (i+j) % 255));    //turn every third pixel on
          for (uint16_t i=0; i < strip.numPixels(); i=i+3) {
            strip.setPixelColor(i+q, 0);        //turn every third pixel off
    // 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);