Arduino based Guitar Pickup Winder

As of 2020 I’ve been messing about with solid body electric guitars since 1986. I’ve built many instruments for myself and others over those 34 years. Sometimes ‘from scratch’ with lumps of wood and my trusty router and other times assembled from parts ordered from places like Warmoth. I’ve turned my hand to pretty much every aspect of this hobby, but never the actual pickups. And there isn’t another component on an electric guitar that influences the tone more than the pickups. So it is time to jump on that bandwagon and make some.

There are a few choices when it comes to pickup coil winding machines. Schatten and Mojotone spring to mind, but they are in the $500-600 range, which is quite expensive. When it comes down to it, all you need is a spinning thing to attach a bobbin to, and a way to stop it when the desired winding count is achieved. My grown-up job is writing code, and I’ve played around with an Arduino a bit in the past. Now is the time to combine all these things and build a machine.

Working Prototype

First some photos. The details are underneath.

The motor is mounted on a vertically mounted board, with a simple wooden plate screwed to the front.
This is for the bobbin to mount to.

I used 6mm MDF as it is very easy to work with, cheap and strong enough for what I’m doing. As I was building this prototype around my breadboard I went with simple L shaped brackets and M4 screws and nuts to hold it together. The small hex head screws you see above are M3 size. MDF isn’t great to drill in that if you don’t have really sharp drill bits (which I don’t) you can get tear-out.

The Hall sensor reacting to the magnet glued on the back of the motor plate. This is used to count rotations, therefore the wind count.

I used a 10mm round neodymium magnet glued to the back of the bobbin plate. I had to make sure I glued it with the correct pole facing the Hall sensor. It would not work otherwise.

A view from the left showing the breadboard underneath the prototype housing. The red PCB is the motor controller, and the green board at the bottom is the Arduino.

As my breadboards were stuck to a reasonably large bit of plywood I was able to secure most components to it without worrying too much about space. The breadboard jumper cables were generally long enough to reach where I needed them to.

My crude control panel. This uses a 2 row, 16 character LCD and 5 momentary (non-latching) switches. This is where the Arduino software really comes into its own.

From left to right these are the button functions:

START/STOP – this will start and stop the motor. It will stop automatically when the desired winding count is reached.

MODE – This switches between RUN mode and SPEC mode.

SELECT – When in select mode this button cycles between the 3 settings: desired count, direction and auto-stop.

UP/DOWN – When editing a specific spec value these two with either increment/decrement the desired count by 100, flip between clockwise/anticlockwise and toggle auto stop. Also, while in RUN mode, the DOWN button resets the counter.

NOTE: I started off using cheap switches I bought off eBay for something like $5 for 10 switches. They were awful and mostly broken. It then crossed my mind that Ive used Switchcraft jacks and sockets for almost 40 years, so maybe they make switches? You know…Switch….Craft? And waddaya know? They make very good switches for about $4 a piece, and the work extremely well.

A Humbucker bobbin mounted on double-sided tape, with a few windings to get things going. I am hand-turning the bobbin plate and moving the wire to each side to set the limiters.

This is the very start of my first winding attempt, so this was very exciting. I had the spool of wire on the floor sitting on its side so that the wire could spool off freely. I was going to be holding the wire between my thumb and first finger to maintain tension. How much tension? I had no idea. So my fingers would be just out of shot a few centimeters below the limiters and I would be moving from side to side to spread the wire across the bobbin. Before hitting the start button I moved the wire towards the middle of the bobbin. At this point I had no idea how it would feel once the winding started. Would the wire snap? Would it spin around in a wild fashion and I’d have a ball of copper wool on my hands?

A photo after winding for 15 seconds or so.

It turns out this is easier than I expected. I find myself staring along the wire as it goes on to see the edges of the coil as it builds up. You can sense a shape forming as naturally doing this by hand isn’t really all that accurate. So that led to one varying the speed at which I moved left and right to keep things even. A genuine coil winding engineer would call this a failure. Guitarists call it ‘scatter wound’ and have somehow legitimized it through force of will.

And there it is. A finished coil. I have a bit of gaffer tape on the wire just to hold it in place. I had not yet bought the correct paper-based tape, which is much thinner.

Basics of Operation

For this prototype all I wanted to achieve was this: “Spin a bobbin at approximately 1000rpm for a given number of revolutions”

To achieve the machine had to be able to do the following:

• DC motor controlled by pulse-width-modulation (PWM) using Arduino and an L298
• Keep track of revolution count using a Hall sensor.
• Specify motor direction.
• Stop the motor when we achieve the revolution count.

And that’s really it. The following quick video shows the Hall sensor in action, a quick demo of editing the count, and a short run showing the auto-stop mechanism.

Component Details

Item	Source	Comment
Switchcraft 933 momentary switch	From Mouser	These work flawlessly compared to the cheap crap ones I got from China on eBay
Greartisan 12 volt DC 1,000 RPM motor	eBay	I’m not impressed by this motor as even though I am using PWM and a motor driver board I cannot get variable speeds. But it works fine for the prototype.
L7812 voltage regulator	SparkFun	A basic voltage regulator to give me smooth DC from my 18v supply.
18V AC supply	?	I had some 18V 3 amp power supplies laying around, so I used one along with a rectifier I made with some diodes. That’s what fed the L7812 regulator.
HD44780 based LCD	eBay	The usual LCD 16 character, 2 row display with the I2C board attached so I don’t use up too many Arduino pins.
L298 based motor driver	Amazon	Again, this one connects via I2C, so it’s trivial.
A3144 hall sensor	Amazon	I liked this board mounted Hall sensor as it had a built in LED, which made aligning the magnet easy. Otherwise it’s a normal non-latching sensor.

The source code

This is my first Arduino code, so forgive the lack of brevity.

To summarize this code in one sentence: “decide on what to do with the motor based on internal state controlled by the buttons”.

In RUN mode you get to start and stop the motor, wherein it starts counting revolutions until it gets to the desired value. In SPEC/EDIT mode you use other buttons to cycle through each value and change them with the UP/DOWN buttons.

#include <Wire.h>               // Library for I2C communication
#include <LiquidCrystal_I2C.h>  // Library for LCD

// Wiring: SDA pin is connected to A4 and SCL pin to A5.
// Connect to LCD via I2C, default address 0x27 (A0-A2 not jumpered)
LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 16, 2); // for 16x2 LCD.

const int motor1pin1 = 11;
const int motor1pin2 = 12;
const int startStopButtonPin = 4;
const int modeButtonPin = 5;
const int selectButtonPin = 6;
const int upButtonPin = 7;
const int downButtonPin = 8;
const int enaPin = 9;
const byte interruptPin = 2;

const int SPEC_SUMMARY = 0;
const int WINDINGS_EDIT = 1;
const int DIRECTION_EDIT = 2;
const int AUTO_STOP_EDIT = 3;

const int RUN_MODE = 42;
const int SPEC_MODE = 84;
const int CLOCKWISE = 1;
const int ANTI_CLOCKWISE = 2;

boolean runMode = true;
boolean shouldBeRunning = false;
boolean shouldRedraw = true;

boolean clockwise = true;
boolean autoStop = true;
unsigned long desiredWindingCount = 4500;
volatile unsigned long totalRevolutions = 0;

int currentSpecSelection = 0;

struct ButtonModeStruct {
  int pin;
  int buttonState;
  int lastButtonState = LOW;

  // the following variables are unsigned longs because the time, measured in
  // milliseconds, will quickly become a bigger number than can be stored in an int.
  unsigned long lastDebounceTime = 0;  // the last time the output pin was toggled
  unsigned long debounceDelay = 75;    // the debounce time; increase if the output flickers
};

typedef struct ButtonModeStruct ButtonMode;

ButtonMode startStopButton;
ButtonMode modeButton;
ButtonMode selectButton;
ButtonMode upButton;
ButtonMode downButton;

void setup() {

  lcd.init();
  lcd.backlight();

  Serial.begin(9600);

  // These two govern direction
  pinMode(motor1pin1, OUTPUT);
  pinMode(motor1pin2, OUTPUT);

  pinMode(enaPin, OUTPUT); //PWM for averaged voltage, therefore motor speed

  pinMode(startStopButtonPin, INPUT);

  startStopButton.pin = startStopButtonPin;
  modeButton.pin = modeButtonPin;
  selectButton.pin = selectButtonPin;
  upButton.pin = upButtonPin;
  downButton.pin = downButtonPin;

  attachInterrupt(digitalPinToInterrupt(interruptPin), count, RISING);
}

void loop() {

  checkModeButton(&modeButton);

  if (runMode) {
    currentSpecSelection = 0;
    checkStartStopButton();

    renderRevCount();
    
    if (shouldBeRunning) {
      startMotor();
    } else {
      stopMotor();
    }
    
    if (shouldRedraw) {
      renderRunModeDisplay();
      shouldRedraw = false;
    }

    // Use this for reset when in run mode
    checkDownButton(&downButton);

  } else {

    stopMotor();

    totalRevolutions = 0;

    checkSelectButton(&selectButton);

    checkUpButton(&upButton);
    checkDownButton(&downButton);

    if (shouldRedraw) {
      renderSpecModeDisplay();
      shouldRedraw = false;
    }
  }

  delay(1);
}

void renderRevCount() {
  lcd.setCursor(9, 1);
  lcd.print("#:");
  lcd.print(totalRevolutions);
  lcd.print("        ");
}

void count() {
  totalRevolutions++;
  if (autoStop) {
    if (totalRevolutions > desiredWindingCount) {
      shouldBeRunning = false;
      totalRevolutions = 0;
    }
  }
}

void renderAutoStop() {
  //autostop
  lcd.setCursor(10, 0);
  lcd.print("Auto:");
  if (autoStop) {
    lcd.print("Y");
  } else {
    lcd.print("N");
  }
}

void renderCount() {

  //count
  lcd.setCursor(0, 1);
  lcd.print("No.:");
  lcd.setCursor(4, 1);
  lcd.print("      ");
  lcd.setCursor(4, 1);
  lcd.print(desiredWindingCount);

}

void renderDirection() {
  //direction
  lcd.setCursor(10, 1);
  lcd.print("Dir:");
  if (clockwise) {
    lcd.print("CW");
  } else {
    lcd.print("CC");
  }
}

void renderSpecModeLabel() {
  lcd.setCursor(0, 0);
  lcd.print("Mode:SPEC   ");
}


void renderEditModeLabel() {
  lcd.setCursor(0, 0);
  lcd.print("Mode:EDIT   ");
}

void renderSpecModeDisplay() {

  if (currentSpecSelection == SPEC_SUMMARY ) {
    lcd.clear();
    renderSpecModeLabel();
    renderAutoStop();
    renderCount();
    renderDirection();
  }

  if (currentSpecSelection == WINDINGS_EDIT ) {
    lcd.clear();
    renderEditModeLabel();
    renderCount();
  }

  if (currentSpecSelection == DIRECTION_EDIT ) {
    lcd.clear();
    renderEditModeLabel();
    renderDirection();
  }

  if (currentSpecSelection == AUTO_STOP_EDIT ) {
    lcd.clear();
    renderEditModeLabel();
    renderAutoStop();
  }
}

void renderRunModeDisplay() {
  lcd.setCursor(0, 0);
  lcd.print("Mode:RUN            ");
  renderCount();
}

void checkSelectButton(ButtonMode * button) {
  // read the state of the switch into a local variable:
  int reading = digitalRead(button->pin);

  // If the switch changed, due to noise or pressing:
  if (reading != button->lastButtonState) {
    // reset the debouncing timer
    button->lastDebounceTime = millis();
  }

  if ((millis() - button->lastDebounceTime) > button->debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != button->buttonState) {
      button->buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (button->buttonState == HIGH) {

        if (currentSpecSelection == 4) {
          currentSpecSelection = 0;
        } else {
          currentSpecSelection = currentSpecSelection + 1;
        }

        shouldRedraw = true;
      }
    }
  }

  // save the reading. Next time through the loop, it'll be the lastStartStopButtonState:
  button->lastButtonState = reading;
}

void handleUpButton() {
  if (currentSpecSelection == WINDINGS_EDIT) {
    desiredWindingCount = desiredWindingCount + 100;
    if (desiredWindingCount < 100) {
      desiredWindingCount = 100;
    }
  }

  if (currentSpecSelection == DIRECTION_EDIT) {
    clockwise = true;
  }

  if (currentSpecSelection == AUTO_STOP_EDIT) {
    autoStop = true;
  }
}

void handleDownButton() {
  if (currentSpecSelection == WINDINGS_EDIT) {
    desiredWindingCount = desiredWindingCount - 100;
    if (desiredWindingCount < 100) {
      desiredWindingCount = 100;
    }
  }

  if (currentSpecSelection == DIRECTION_EDIT) {
    clockwise = false;
  }

  if (currentSpecSelection == AUTO_STOP_EDIT) {
    autoStop = false;
  }

  if(runMode) {
    totalRevolutions = 0; 
  }
}

void checkDownButton(ButtonMode * button) {
  // read the state of the switch into a local variable:
  int reading = digitalRead(button->pin);

  // If the switch changed, due to noise or pressing:
  if (reading != button->lastButtonState) {
    // reset the debouncing timer
    button->lastDebounceTime = millis();
  }

  if ((millis() - button->lastDebounceTime) > button->debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != button->buttonState) {
      button->buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (button->buttonState == HIGH) {
        handleDownButton();
        shouldRedraw = true;
      }
    }
  }

  // save the reading. Next time through the loop, it'll be the lastStartStopButtonState:
  button->lastButtonState = reading;
}

void checkUpButton(ButtonMode * button) {
  // read the state of the switch into a local variable:
  int reading = digitalRead(button->pin);

  // If the switch changed, due to noise or pressing:
  if (reading != button->lastButtonState) {
    // reset the debouncing timer
    button->lastDebounceTime = millis();
  }

  if ((millis() - button->lastDebounceTime) > button->debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != button->buttonState) {
      button->buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (button->buttonState == HIGH) {
        handleUpButton();
        shouldRedraw = true;
      }
    }
  }

  // save the reading. Next time through the loop, it'll be the lastStartStopButtonState:
  button->lastButtonState = reading;
}

void checkModeButton(ButtonMode * button) {
  // read the state of the switch into a local variable:
  int reading = digitalRead(button->pin);

  // If the switch changed, due to noise or pressing:
  if (reading != button->lastButtonState) {
    // reset the debouncing timer
    button->lastDebounceTime = millis();
  }

  if ((millis() - button->lastDebounceTime) > button->debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != button->buttonState) {
      button->buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (button->buttonState == HIGH) {
        runMode = !runMode;
        shouldRedraw = true;
        if (runMode) {
          Serial.println("run");
        } else {
          Serial.println("spec");
        }

      }
    }
  }

  // save the reading. Next time through the loop, it'll be the lastStartStopButtonState:
  button->lastButtonState = reading;
}

void checkStartStopButton() {
  // read the state of the switch into a local variable:
  int reading = digitalRead(startStopButton.pin);

  // If the switch changed, due to noise or pressing:
  if (reading != startStopButton.lastButtonState) {
    // reset the debouncing timer
    startStopButton.lastDebounceTime = millis();
  }

  if ((millis() - startStopButton.lastDebounceTime) > startStopButton.debounceDelay) {
    // whatever the reading is at, it's been there for longer than the debounce
    // delay, so take it as the actual current state:

    // if the button state has changed:
    if (reading != startStopButton.buttonState) {
      startStopButton.buttonState = reading;

      // only toggle the LED if the new button state is HIGH
      if (startStopButton.buttonState == HIGH) {
        shouldBeRunning = !shouldBeRunning;
      }
    }
  }

  // save the reading. Next time through the loop, it'll be the lastStartStopButtonState:
  startStopButton.lastButtonState = reading;
}

void startMotor() {
  if (clockwise) {
    digitalWrite(motor1pin1, HIGH);
    digitalWrite(motor1pin2, LOW);
  } else {
    digitalWrite(motor1pin1, LOW);
    digitalWrite(motor1pin2, HIGH);
  }
  analogWrite(enaPin, 255);
}

void stopMotor() {
  analogWrite(enaPin, 0);
}

What’s Next?

I’d like to improve a few things to fully automate the winding of a pickup coil:

• Servo motor with rack and pinion to guide the wire across the bobbin for even spread.
• Tension system to feed the wire properly.
• Something to house the wire spool. It tends to flap about wildly as it spools off the reel. Britain built an Empire off solving this problem so perhaps a 200 yr old book will have answers? I was thinking a smooth plastic tube would do the trick.
• A decent housing for the entire machine. i.e. take it beyond a prototype.
• 5V power supply. Currently it is powered off my Mac’s USB bus for 5V.
• The motor I have is crap. It will do 1000rpm at 12V, but it’s only getting 10V via the drive board so it’s slower than that. I need a motor that will do as much as 1500rpm but also speeds lower than that so I can do a slow start.

Finished pickups

Two finished coils that in series gave me 7.06k DC resistance, which is at the low end of what I wanted. This first one was for the bridge position and each coil had 4500 winds of 42AWG poly coated wire. The magnet is Alnico 5.

December 2020 – Simon Allaway

Assembling a King of Tone clone

I’m sure if you’re the kind of person to be reading a blog about building pedals you will have heard of the King of Tone. It is a much sought after guitar pedal on the same list as the Tubescreamer or FuzzFace.

So what makes this pedal so good?

For me it’s the way it feels to play it. It’s true that there isn’t a lot of gain on hand, but then again that’s not what I’m into. I find that it does a very good job at recreating the feel and tone of an amp that has been cranked to the point of overdrive, and then pushed a little bit more. But it doesn’t have a ton of harshness to it. It is as if the front of the note has been compressed ever so slightly. But not so much that you’d think you were using a compressor.

I also find that it sounds good with any type of guitar. Telecaster, Les Paul (PAF or P90) or Stratocaster. It’s incredibly versatile.

Quotes from the original description:

“The King Of Tone overdrive was designed to take an amp at reasonable settings, and make it sound like it would sound if it were naturally driven to pure, smooth, tube distortion.”

“The KoT is one of the few overdrive pedals available that is NOT based on a Tube Screamer circuit. In OD mode, it has a little less drive available than a Tube Screamer. It has quite a bit more volume available than a Tube Screamer and The TONE control has a similar range. The KoT has less compression than a tube screamer, and also does not boost the mids or cut the low end as much. It does not have a large amount of distortion.”

Where to begin?

The beginning of assembly. I use my iPad to mark off components as ‘done’ when I have completely installed them.

Naturally I would need a PCB, the components, any off-board furniture such as pots/switches, and an enclosure.

I began with a board from Pedal PCB. They have a model called the Paragon, which at the time I bought it was about $10. I would have paid double as this is so well made. The build documents on that product page are very good.

The components came from the usual suspects:

1. Tayda
2. Mouser
3. Love My Switches

 

Diodes

You can see the sockets I used for the diodes above the DIP switch.

Probably the biggest influence on the responsiveness of the pedal is down to the clipping diodes. I found a set of “correct” diodes on eBay for about $20, which on the surface is a ridiculous price, but I’m not buying thousands so who cares? I added single-in-line sockets for one side of the pedal so that I could mess around with other diodes later.

The rest of the assembly was fairly simple. If I did it again I would follow the instructions more precisely and drill the enclosure prior to soldering the PCB mounted pots. It makes total sense that using the holes to line things up helps a great deal. But I’m impatient and I did not have a drilled enclosure to hand.

 

 

Testing the finished board using my iPad

After drilling 1/8″ pilot holes I attack the enclosure with the step-bit.

I had to ream out the holes a little to get everything to fit because I added the PCB mounted pots without the enclosure. I knew this was bad as it said so in the build docs, but I’m impatient.

Time for a decal

Done! For now.

Here’s a quick demo of the pedal:

 

Fixing a broken Dunlop Crybaby Wah pedal

This one was easy, but very effective. I’d played a gig where all of a sudden my guitar signal kept cutting out. After much guitar swapping, and cable wiggling it became clear that I had a problem with my wah pedal.

Upon further investigation one of the Cliff style jacks had worn out and wasn’t allowing a good solid ground connection. I decided to replace them both with good old Switchcraft style jacks.

Secondly, the DC power input was the 1/8″ jack style, which was irritating as every other pedal (except perhaps old DOD pedals) use the 2.1mm system. So I swapped that too.

All three holes required a little enlargement, so I simply used a hand reamer. These are so much less destructive than a drill.

This Wah cost me $20 on eBay many years ago and all I had to do originally was…nothing. It was sold as broken, but in fact the only thing wrong was a broken 9V battery connector, which I didn’t need anyway. Bargain!

The original circuit, with it’s PCB mounted input/output jacks, and the old power socket.

The repaired board with Switchcraft jacks, and a standard 2.1mm power socket.

The only clue it is non-standard is the appearance of the power socket.

Guitar Fetish “Gold Foil P90 Humbuckers” – in a Les Paul

My Gold top

I’ve owned my Gibson Les Paul Deluxe (made somewhere between ’75 and ’77) since about 1991. It came with P90 pickups, which sound glorious. They’re definitely thinner than your regular humbuckers, but thicker than Fender single-coils. I don’t like mushy tones, so this combination is great for me. The only trouble is, they are really noisy. This is exacerbated by the modern world, which is full of computers (and phones) and Compact Fluorescent bulbs, which all put out a lot of RF interference.

One possible solution was to fit normal humbuckers to my LP, but that would require destructive routing. I chose to go for some P90 sized humbuckers instead…..some of these from Guitar Fetish. They’re the right size, and they’re humbuckers!

Fitting them was relatively easy, just a 20 minute job. The only problem that presented was that the new covers didn’t want to fit inside the old routes, so I tried the old covers and they fit over the new pickups perfectly. So now I have retained the look of the originals.

Some observations:

• These are very quiet P90-like pickups
• The P90 style pole pieces are just for show. These humbuckers have blades inside the coils.
• As you can see from the photos, the gold foil isn’t visible due to my use of the old covers.
• The neck pickup is very loud, whereas the bridge pickup isn’t so much. Time will tell as to whether this is an issue.
• I’ve yet to compare them to my Telecaster, but is suspect these gold foils are louder.
• I need to replace the potentiometers as they’re quite corroded. Time to get some CTS pots, or perhaps splash for an Emerson set.

Original P90 neck pickup

Original P90 neck pickup and new Gold Foil

Gold foil cover doesn’t fit, so here’s the old cover on the new pickup

Rewiring a Telecaster with a four-way switch

Conventional 3-way switching

I’m willing to be that 99.9999999% of Telecasters are equipped with the conventional 3-way switch that offers up the bridge pickup, the neck and bridge in parallel, and then finally the neck pickup on its own. Time has shown this to be perfectly satisfactory as those 3 different tones have been and continue to be “go to” tones for musicians world-wide. My interest in Telecasters comes from a range of guitarists:

Mark Knopfler

He used one on many tunes like Espresso Love, and even the grotesque Walk Of Life. His Tele tone was always fat and chunky. I don’t know which Tele he used on early tracks, but since late ’79 he used ones built by Schecter back when they really built custom guitars.

George Harrison

He’s famous for his gorgeous rosewood Telecaster, which he used to great effect on “I Want You (She’s So Heavy)”. You can hear him switching between neck and bridge as he plays over verse and chorus, and then the big riff at the end as he grinds through on the bridge pickup.

Joe Walsh

One of my favourite solos ever is the two-player epic that is Hotel California. A fantastic battle between Don Felder on a Les Paul and Joe Walsh on a Tele. You get to hear the difference between the two guitars…the thick bite of the Les Paul, and the sweet glassy edge of the Tele (probably set to both pickups in parallel…the normal middle position).

Conventional 3-way pickup wiring for Telecaster

Why 4?

Over the years I’d always heard that one could get different tones out of a Tele by wiring the middle position so the pickups were in series, rather than in parallel. And that this would give you a “big sound”. That didn’t make much sense at the time, but as I hadn’t ever heard this configuration, I had no reason to doubt it. But I had to try it myself one day.

Recently I spotted a pre-wired kit from Emerson that went for about $65. They do such a lovely job of the wiring I seriously considered getting one. But that’s cheating, so I bought essentially the parts for it from Stewart McDonald so I could build it myself.  Here’s the parts kit. They also sell the ludicrously expensive capacitor that Emerson includes.

The alternate 4-way switch wiring diagram

Pickups

My lovely wife bought me a set of “Vintage Noiseless” Telecaster pickups, made by Fender. That’s just how lovely she is. So this was a perfect time to install those too. I had originally installed a Schaller telecaster pickup in the bridge and a no-name neck pickup. They sounded OK, but in this modern world of computers-as-tape-recorders and compact-fluorescent bulbs, they were very, very noisy. Second only to the P90s in my Goldtop, but that’s another story. A third reason for doing this is that the cheap Japanese 3-way switch I’ve had in it for almost 15 years was failing quite quickly.

So, the wiring wasn’t hard. The only thing that slowed me down was I decided to use the fabric covered wire that came with the StewMac parts kit. I;d never used it before. You’re supposed to cut to length, and then push the fabric back to revel tinned wire. All cool so far, but then the fabric springs back making it a little hard to solder even if you get a good mechanical joint. I’m used to using Teflon covered wire that I strip before soldering. Anyway, it looks cool, so I won’t whine too much. Here’s some photos.

Here are the noiseless pickups sat waiting for me to begin removal of the old pickups.

Wiring complete! You can see the ludicrously overspecced 200 volts capacitor, from Emerson.

Re-assembled and re-strung

Sound demo

The only thing left to do was to plug it in and see what it sounds like. Here’s a quick recording of me noodling around in Em, and switching between each position. This is plugged straight into my AX84 single-ended tube amp, set to be somewhat crunchy, into my 2×12 cab with celestions. Recorded with an SM57 right into a Mac.

I begin on the bridge pickup. The switch to neck and bridge (parallel) is at 1:49, the switch to neck alone is at 2:43, then to neck and bridge (series) at 4:14.

Building a “static wah” pedal on veroboard

What is a wah pedal?

A normal “wah pedal” is a device that you drive with your foot. When you waggle it back and forth it makes your guitar sound like a human literally going “wah wah”. It was built (possibly by accident) to emulate the way a trumpet player might use a hand-held mute, but it doesn’t really sound much like that on a guitar. It is definitely its own sound. To understand the ‘traditional’ circuit here’s just about the best explanation ever written about them. Indeed, within weeks of the first useful device appearing on the market, Eric Clapton was using it on the Cream track “Tales of Brave Ulysses” to great effect. Then it became de riguer, and the likes of Hendrix, Beck and even George Harrison took it to great heights themselves. And for us amateurs, a pedal board is not complete without one. I currently have a Boss V-Wah, which does a passable simulation of a standard Cry Baby wah, as well as others.

Jimi doing the wah thing

What is a “static” wah pedal?

Sometimes when you’re playing with a wah pedal you end up leaving it turned on without your foot on the pedal. And sometimes it will even sound good. Legend has it that Mark Knopfler played the Money For Nothing intro using a wah pedal left in a certain fortuitous position. After reading various interviews about those mythical sessions, it’s not so clear. It seems the tone was achieved accidentally with some unorthodox positioning of the mics, which implies their locations created odd phase relationships, which in turn may have sounded as if someone used a notch filter (kind of like a wah). But then this one talks about Knopfler himself describing the concept of a static wah. I read a third interview once (can’t find it now) that supports both. i.e. the studio recording was the accidental mic positioning, whereas when MK tried to recreate the tone elsewhere he tried using a wah pedal (in a static position). Either way, I want to build a static wah for a second, and perhaps more important reason: Robin Trower uses a static wah for solos. Here’s Mike Fuller, from Fulltone:

11 years ago I made a couple of fixed wah wah effects I called the Wahfull®… they were simply the guts from a wah wah stuffed inside a box with a knob so you could find that perfect Mid-Boost sound every time you kicked it on. Nice effect, sold a few, moved on. Last year Robin Trower called me and said he was doing some gigs with Jack Bruce and asked “Would it be possible to have a wah wah in a regular box so that one could get that “fixed wah” sound by clicking on the pedal?” So I made one up and he’s been using it ever since.

Here it is in all its glory on Trower’s stage rig:

Trower’s rig – including the Wahfull

* Note how Trower doesn’t use a power supply, or even a pedal board. Rock ‘n’ Roll!

Bringing it to fruition

So, all I had to do was find a decent circuit, and make the damned thing. I didn’t have to worry about buying either a broken wah or buying a new empty enclosure as this will fit in a standard pedal enclosure, such as the 125B I had laying around. I found a circuit on Sabrotone’s site: Here are the useful features over and above a normal wah circuit:

• A ‘gain’ control to add a bit of grit/boost. I am a big fan of using a booster to give you a bit of “ooomph” when entering a solo.
• a ‘Q’ control to change the width of the notch. This offers flexibility for little cost.
• A ‘volume’ control to help match levels, especially when you’ve cranked the Gain a bit.
• A multi-position rotary switch to adjust the main filter’s capacitor. Again, flexibility is good if it doesn’t degrade tone.

The mods are such that it still retains its bog-standard Vox circuit, but it becomes a little more useful for modern times.

The layout

The Sabrotone “WahWithMods” layout

 

Almost there

 

I forgot to drill the hole for the capacitor switch. Doh!

 

The finished article

Demo

Here’s a demo clip. It’s with the usual setup: my Tokai Les Paul, the one with the 1961 hum bucker in the neck. It’s going into the static wah, then my Box of Rock clone. Then into my AX84 amp, into a 2×12 cab.

I start off with the clean signal, then I turn on the way. Then I turn off the wah, and turn on the Box of Rock for a second. Then the wah goes back on. Each time the wah goes on I begin with the frequency knob anti-clockwise and work my way around to maximum. This is the same as rocking a wah pedal from back to front. You can hear that happening especially in the overdriven section. 

Building a PT2399 based delay pedal

The populated board, close-up

My friend at DIYEffects was kind enough to send me a PCB he had constructed for a delay pedal. His is based on a PT2399, which is a very popular (and extremely cheap) integrated circuit that will take an audio signal and produce an echo of up to 500-600 milliseconds. It does all this in 44k of digital memory. That’s nothing at all. Oh and they cost about $2 at the time of writing. Seems too good to be true?

Maybe. There are compromises of course. Mainly in what amounts to fidelity of the repeating signal. With only 44k of memory there’s no way this will be a sparklingly clean 16bit/44 kHz digital delay that you might expect from Lexicon. As is fairly typical in the world of guitar effects, it turns out nobody actually wants a crystal clear delayed signal. If you ever get to try it out you’ll find that the repeats tend to drown out the dry signal as a hi fidelity ‘wet’ signal will have all the same frequencies as the dry signal so it kind of stomps all over it. The ‘low fidelity’ wet signal of the 2399 has somewhat muted high frequencies, so it sits under the dry signal quite nicely.

Problems!

The biggest issue I had with this circuit was that it would only work intermittently. In fact, it worked perfectly on first power-up, and I was able to play it for an hour or so with no issues. But when I came back to it this year ( I had populated the board and got it running a couple of years ago) and fired it up, there were no echoes. None at all.

I always blame power first, so I did some measurements to ensure that the op-amp had some power, and the 2399 chip itself had things in the right place. It looked like the 5v regulator wasn’t quite doing what it should, so I replaced that and made sure the pinouts were going to the right sockets. This helped as now I had a steady 4.8v at pin 1 (Vcc) of the 2399.

Still no echoes though. I read a post (here) that talked about “latching problems”:

First, I’ve had the PT2399 ‘lock up’ on me two or three times now.  When this happens the circuit passes signal but you get no delay.  The regulator inside also gets hot (and could cut out I guess).  The effect can come back to life with the same PT2399 after disconnecting it from the power supply for a spell.

This sounds exactly like the issue I’m having. So this post lead to one from Merlin himself:

Some devices appear to latch up or fail to function properly if digital ground (pin 4) is left unconnected. This pin should usually be connected to analog ground (pin 3).

So I made a simple jumper from some scrap bits of stranded copper wire, and soldered it across pin 3 and 4. Problem solved.

A real effects pedal power-supply

Why?

Over my playing years (more than 30 now) I’ve owned many effects pedals, spent a ton on 9V batteries and even tried many different power supply devices. I had one of those VisualSound “1-Spot” daisy chain things, which worked quite well. And recently I was given a Furman SPB-8 which appears to be the mother of all pedal boards. If you’ve been to this site before you know I’ve built an amp, and a whole slew of different pedals. All of these things I mention have one thing in common: there’s a lot of attention paid to converting alternating current from the wall outlet into direct current to power the circuit.

How?

After looking at many different power supply circuits, I realised they looked very simple, but I did not know the first thing about why each component was there and what they did.

My cousin Mike was in need of a power supply for his pedal board that could handle anything that he threw at it (i.e. multiple voltages and a useful current handling capability). Naturally there are products one can buy, such as the Voodoo PedalPower or the MXR Brick, but these can be quite expensive. And lets face it, I wanted to build one, so I could find out how they work.

What?

So, what does this thing need to do? Basically the following is desirable:

• Provide a steady 9 volts.
• Do not introduce noise into the circuit.
• Handle at least ten pedals’ loads, which might approach 1 Amp.
• Be small enough to fit under Mike’s pedal board.

Transform, rectify, smooth and load

From my work with tube amps and reading everything I could find in print or online, it became clear that, at a fundamental level, there are only a few discrete steps to accomplish:

1. Transform the outlet supply from 115V to something closer to the desired voltage.
2. Use a rectifier to convert the AC supply to a DC supply.
3. Use filters to smooth out the now rippling DC.
4. Load the circuit with whatever you wish to actually provide power. Whatever that is, it require voltage, will draw current and therefore has resistance.

A transformer is easy to get hold of. Even Radio Shack sells a 9V AC ‘wall wart’ that will handle 1 amp. A rectifier is easy too; just a bunch of diodes arranged in a certain way.

The filtering though was a mystery. How do you know what values to use? After gathering quite a few different circuits it seemed everyone was using different values, so who had it right?

The idea is this: use the characteristics of a capacitor to ‘fill in the gaps’ of a rippling DC supply. Remember, we rectified AC, which gave us rippling DC. That ripple will be at a frequency that can be heard by us humans, so we need to reduce that ripple to be inaudible.

Here’s a graphic showing a number of things. Firstly, this is a time-series showing voltage over time for the circuit at the top of the bitmap. Its a simple circuit showing an AC source going through a rectifier. Then the AC signal flows across C1, a capacitor. This graphic is to explain how to calculate the value of C1, and the influence it will have on the green waveform, which is the rippling DC source (post-rectification).

Ripple smoothing calculation

So imagine it like this:

1) The rippling DC source voltage rises to reach about 32 volts. During this time C1 is charging.

2) as the DC source starts to come back down, C1 starts to discharge. This serves to “fill the gap” between the ripples.

The chart is showing, with the different coloured lines, the influence of different values of C1 on the rippling DC.

Here’s a great article on this subject.

A more modern approach.

It seems to me that it is rather than painstaking to install a network of capacitors to perfectly smooth out the rippling DC. Also, transformers are far from perfect, so under load they sag, in terms of voltage. Even if you got all your calculations right, under load it will behave differently.

It is far easier, but not necessarily more efficient (in terms of trees and polar bears), to use a voltage regulator. The 78XX series works very well. You give it more voltage than you require, say 12V, and it does the work to provide you with an almost entirely ripple-free steady 9V. Any excess voltage is ‘given up’ as heat. This is why you might need a heat-sink (and why dolphins and rainbows are destroyed). Here’s a typical circuit using regulators:

A typical regulated power supply for guitar pedals

The end result

I came up with a simple circuit that used part of the above circuit to provide 9V and 18V for about 10 pedals. My initial circuit was flawed in that I’d ordered the wrong voltage regulators. They could only handle 100mA. Once we’d connected up all of Mike’s pedals, it would literally cut out. I even connected each one individually to my bench supply so I could measure each ones current draw.

Investigation showed that the regulator was extremely hot, so it became clear that the thermal protection was being tripped. I replaced the 7809V regulators with higher current handling ones and all was well.

Here’s some photographs of that build:

A very simple decal makes the enclosure look quite spiffy, I think.

The circuit mounted inside, with all the DC connectors

The final schematic

And the final schematic, with values underneath:

• D1 – 1N5401
• C1 – 470uF
• C8 – 0.1uF
• D2 – 1N4148
• IC1 – L7809CP
• C3 – 10uF
• R1 – 100R 1Watt
• C2 – 100uF

 

Building a “Tremulus Lune” on vero-board

One of my favourite pieces of music, let alone guitar playing, is by Ry Cooder. A track called “Feelin’ Bad Blues”. This video is an excerpt from the film Crossroads where the tune was used to great effect. For me it is the epitome of blues guitar. Sad, slow and gritty. And that thick tremolo (probably from an old Fender amp, not a Pignose) is the icing on the cake.

So that’s what this post is all about; making a pedal to give me that tremolo effect. It didn’t take long to find the defacto standard tremolo pedal; the Tremulus Lune.

Layout

Layout

Research showed that I could buy a kit, or even a pre-made one, but where’s the fun in that? I went for the layout from Guitar FX Layouts (seen here).

The novelty with this circuit for me was it used a component called a Light Dependent Resistor (LRD). Essentially one part of the circuit is a Low Frequency Oscillator (LFO), controllable with various potentiometers. The ‘low frequency’ part refers to the fact that it is creating a sine-wave in the range of 3-10hz (I haven’t actually measured it). This wave is used to drive a normal op-amp, thus varying amplitude over time, which is in fact the definition of “tremolo”. One difficulty was getting hold of the correct LDRs.  They needed to have the range 5k/500k. It was easy to get hold of all kinds of LDRs, even from Radio Shack, but I had to trawl through Ebay to find the right ones. I have a bag of 20 now.

The build

The finished board

This isn’t my first veroboard build, so the build/assembly went quite quickly, in a pleasant way, and I had it operational on my prototype rig within a couple of hours. It sounded amazing! It truly is a versatile tremolo; you really don’t need anything more complex than this.

The device has three LEDs. One for the usual on/off indicator; another one to couple the LFO with the op-amp (by pointing the LED at the LDR, kind of like a vibe pedal does) and a third one to show the speed of the LFO externally. I decided to use the nice fresnel lens LED holders I bought a while ago. I just think they look really cool. The picture below shows them in their full glory, although the red LEDs look somewhat pink. To fit them I needed to get a 17/64ths drill bit. I have hundreds of drill bits, but not that one. So, a trip to Ace Hardware for that.

Fresnel lenses

The enclosure

This one’s got 5 knobs, so I had to use a 1590BB and I chose to go for a vertical orientation. As for a design I went for the whole Crossroads theme. I combined the lyrics to the famous song, and depicted the actual crossroads by using highway signs. As far as the decal goes, I wanted it to wrap over the sides as I thought it would look cool. I printed it on transparent ink jet decal paper this time as the enclosure is bright white.

Drilling the enclosure

The decal

Demo Recording

So I finished the assembly and got it all plugged into my usual rig, and recorded a swift demo. As I mentioned earlier, the reason I wanted to build this was for that archetypical blues tone. So here’s my own sloppy rendition of that kind of sound:

Click here for MP3

The setup was: Tokai Les Paul, neck pickup (a humbucker from a 1961 ES-335); my AX84 P1 Extreme into a 2×12″ speaker cab, with Celestions; my Box of Rock clone for some grit, and the Tremulus Lune of course. The reverb came from Logic, and was a ‘small church’ kind of setting.

The finished pedal

Building a Z.Vex Box of Rock on vero-board

Why?

As most guitarists will admit, we’re always looking for a better sound. Some look for new and perhaps innovative sounds. Others, such as myself, want to sound like the players we admire. One classic tone I had never really toyed with is the sound one gets when you crank a JTM45 Marshall. In my opinion it is in my Top 5 sounds. The likes of Clapton, Hendrix, Young (Angus), and many others, started their careers with it. There’s no need for me to recount the origins of the circuit as that’s well documented.

So, you might ask “why not just buy a JTM45?”. Well, one in good condition from the 60’s might set you back 5-10 thousand <local currency units>. A new one, such as those available at Ceriatone go for about $1000….a ‘real’ Marshall? more like $1800.

How

One solution is to approximate the tone in a pedal. And yes, I’ve built way too many overdrive/distortion pedals already, but not one like this. The approach here is to cascade two or more gain stages to ape the design of the JTM45. This has been done may times in plenty of pedals, but a popular one is the Z.Vex Box of Rock. I first heard of this device when it was mentioned by Davy Knowles, who is an excellent blues guitarist. Searching briefly online and I found that the design of the pedal built upon the Super Hard On booster; one of which I built last year. This struck me as a great way to go as I understood that circuit.

Schematic

ZVex Box of Rock schematic

Even if you can’t read schematics, you can probably see a pattern repeating itself. There are 4 BS170 transistors arranged as gain stages. They’re chained together and setup in such a way to simulate the characteristics of a tube amplifier. There’s a 4th one (at the bottom right of the schematic) which is the boost section. That will have its own footswitch, so it can be turned on when you “need a bit more”.

I went for a slightly different EQ section. As it stands the BoR just has a simple Muff-style filter. As in, a low-pass filter and a high-pass filter ‘mixed’ together by the tone knob. There’s a great variant that adds a ‘mid scoop’ control, as specified beautifully here by AMZ. It was simple enough that I decided to add it myself.

Layout

I got the veroboard layout from my usual place: Guitar FX Layouts. This guy always does a great job, and is always around to help or explain things. Fantastic!

ZVex Box of Rock – Complete

Build

The build started off ok, but proved tricky. I quickly realised that I’d done something very wrong as it just sounded very odd. I remembered experiences from previous builds and went back with a fresh printout of the layout, and ticked off each cut, link and solder spot, and made sure the component values were correct. It turned out I had got some cuts in the wrong place. Literally as simple as that. I was careful to use sockets for the BS170s; this meant I was able to leave them out until the last minute so as to not expose them to static shock risk.

Enclosure

Spray and bake – the black paint hardening under the lights

I went for some custom graphics again. As is typical I couldn’t really think of anything particularly innovative, and ended up calling it “Bed Rock”. This stands to mean two things: 1) This tone is the bed-rock of modern music 2) You can get that tone at low volumes so you can ‘rock’ in your ‘bedroom’. I know, cheesy.

Most of all I wanted to created something with a splash of colour. So many pedals look so very boring. I did the usual flow of finishing the enclosure with enamel based spray paint. This time it was a cheap can of black from Ace Hardware. I was actually going to try something new and bake the enclosure in a toaster oven, but I realised that I was already doing a kind of slow bake with my work-lights. And as I wasn’t in a hurry, I stuck to my usual routine.

For the decal itself, I used a combo of Photoshop and Illustrator to create an image. It was printed on my trusty HP Office ink-jet printer, onto white-backed decal paper; purchased from Small Bear Electronics.

One pleasant discovery was that you can get high-quality fonts for free at sites like FontSpace. Here’s the one I used for the main wording, All Ages.

Almost there!

The finished ‘Bed Rock’

Demo

I think it came out well. With a Les Paul, it’s ridiculously easy to get that classic AC/DC rhythm tone with everything at 12 o’clock, and with the boost section kicked in you’ve got just that little bit more sustain available for a solo. Even a Strat sounds good. On mild gain settings it really makes single-coils come alive. I ought to do a recording of that too, I suppose. Here’s a demo file of the device.

My setup is the same as usual: Steinberger GM-7SA plugged into an AX84 tube amp, running clean into a 2×12 open-backed cab, with Celestion G12-75T speakers, miced by a Shure SM57 being recorded by an Apple Mac.