Sunday, August 23, 2009

The Bass Guitar Build – Part 3

This is the third post in a series describing the construction of a bass guitar. This is a project that my son and I took on when he stumbled into the opportunity to purchase a Jackson Bass Guitar body and neck for a pretty good price.

I’d like to describe the installation of the electronics in this post. Unfortunately I don’t have as many photos as I would have liked. In the previous guitar build, I has easily spent 80% of the time on refinishing the body. Now the body was done and the rest would be easy; pop in the pickups, insert the potentiometers, throw in some solder in strategic places and BAM! Sound.

Or so we thought.

Those Damn Pickups

For pickups we went with EMG Selects. EMG makes good pickups and Stewart-MacDonald had them at a good price.

We unpacked the pickups and did a dry-fit. This is where the problem began. The routing for the pickups was much deeper than the pickups themselves so the they fell to the point where they were flush with the guitar body.


The Fender support site recommends a pickup height of 7/64” on the bass side and 5/64” on the treble side. We tried using a piece of wooden pencil but that wasn’t high enough. We then tried cutting a shim from a scrap block of wood but that also wasn’t giving us the right fit.

I remember from the previous build that the pickups were mounted in a spring loaded housing. I went scurrying around the house looking for pens to steal the spring from. All I could find were three pens. I needed eight.

I them remembered that my wife had just purchased a new hair dryer because the previous one had burned out. (I bet you’re thinking “Where the hell did this come from?” Well, what is the heating element in a hair dryer? A couple of coils wrapped around a tube. What is a spring? A compressed coil. ) I rushed upstairs to grab the old dryer out of the recycle bin and proceed to dismantle it.

I unwound one of the coils and cut it off the tub. It was then easy enough to cut the eight springs that we needed.


We threaded the mounting screws through the pickups and through the springs. Then popped them into the routings in the body. The springs gave the right amount of lift so we were able to get the recommended height.

Note: When reciting this story to one of the instructors at the music school where my son takes lessons, he mentioned that some builders us foam padding under the pickups to achieve the same effect. That probably would have been easier if I had some laying around.

With the pickups mounted, we mounted the potentiometers for the volume and tone controls.



If you’re interested in building a guitar, don’t let the wiring portion of the project scare you. In my opinion, dealing with the body and paint is much harder than the dozen or so solder connections that you have to make. Even getting all the parts is easy if you purchase a wiring kit. For this project, I purchased the wiring kit from Stewart-MacDonald. It comes with three pot, the capacitor, jack, wiring and a wiring diagram.

Here’s the wiring diagram that we used:


This is really an easy project for someone that has never used done any soldering work before. The only difficulty might be in the tight workspace of the control cavity. Just remember to cover as much of the guitar’s body as possible in the event of any solder drips.

Unfortunately I don’t have any pictures of the wiring work. I will say that it didn’t take long for my son to burn himself on the soldering iron. Also, here’s a tip: periodically run the tip of the soldering iron on a foam sanding block. After a while, the tip will become covered with a layer of residue that prevent interferes with heat transmission. The sanding block removes the residue quickly. It will make the work good much faster and easier.

Once the wiring is completed, we used a multi-meter to check that all the connections where good, including all the grounds. We then mounted the jack into the jack-plate and screwed it to the body. Now it was time to hook the guitar to the amp and test everything.

We used a nickel to gently tap each pickup to verify that it was producing a sound. Everything worked as expected.

The small stuff

Now that the wiring was completed, we could finish the rest of the body work. That included installing the control-cavity cover, the strap buttons, neck, tuners and the nut.

I purchased a nut that was pre-cut for a four-string bass guitar. To install it I cleaned up the area where the previous nut had been. We then installed the two outer strings to help position the nut correctly. A thin layer of glue is applied to both the neck and nut, and then the nut is clamped into position.

P1000419 P1000421 P1000420 P1000423

All that was left was to install the strings and do the setup. As you might expect, that was the start of a new adventure. I’ll save it for the next post.

Wednesday, August 19, 2009

The Bass Guitar Build – Part 2

This is the second installment of the Bass Guitar Build. If you’re just jumping in, my son and I purchased the body and neck of a Jackson Bass Guitar. It has been stripped of everything else by the previous owner so we were able to get it cheap.

In part 1, I described the work that my son and I did to repair three chips in the body. Here I’d like to continue describing the rest of the body work that we had to do.

The Control Cavity Cover

The original control cavity cover was also missing when we purchased the guitar so I ordered a new one from Stewart-MacDonald. From the looks of it, the original was mounted straight onto the back. Since I was already working on the body, it was easy enough to route space around the control cavity so that the cover would lay flush instead of on top.

P1000408 P1000409 

I don’t own a router but I do have a Dremel. I used a  router bit and was able to remove the unnecessary material from around the control cavity with little trouble.


After dry-fitting the cover so that we could drill holes for the screws, I decided to paint the fresh wood to match the rest of the body. It just seemed like a nice touch.


The Bridge

Next we turned our attention to mounting the bridge. There was a hole near the middle screw for a bridge ground but it wasn’t drilled through to the control cavity. Now, a guitar body is not that thick, maybe 2 or 2 1/2 inches but the control cavity is not in the middle of the guitar. It’s all the way to one side. The hole for the bridge ground has to be drilled at an angle, a very slight angle. This takes a very long, thin bit – that I don’t have. Luckily I learned a trick where a segment of coat hanger can be used as a make-shift drill bit. You just have to snip one end at a slight angle to create a very sharp point.

So my son and I did some guessing at what the angle should be to go from the bridge to the control cavity and we put our make-shift bit to use. Well, we got really lucky. We came out about 3/4 of an inch short of the control cavity but still within the area that I had just routed out. I broke out the Dremel (I love that tool!) and cut a channel from the hole into the control cavity so that the cover would still lie flush.


To mount the bridge, I ran a wire from the control cavity, through the new hold, and folded one end into one of the screw holes. We then aligned the bridge and popped in the back screws. Our bridge required that we drill two new screw holes in the front. The original bridge used only five screws, ours required seven.


We could turn our attention to the electronics now that the the body work was completed. And that will be the topic for the next post in this series.

Monday, August 10, 2009

Upgraded the laptop to Windows 7

I’ve had Windows 7 on my Dell Vostro 1500 laptop since the RC was made available. For the RC, I took the opportunity to get a new hard drive. I wanted to create two partitions. One for the OS and one for data. I periodically repave the machine and it’s painful every time. So I look for opportunities to minimize the hurt.

That’s why I started doing all project work and installing betas in virtual machines (VMware Workstation). I don’t have to worry about a refresh affecting one of my projects nor do I have to worry about an install for one project affecting another.

When I read that Windows 7 was to be released,I wasn’t looking forward to spending the hours reinstalling. I was quite pleased when a co-worker brought this article to my attention.

I followed the instructions, using VMware Workstation to mount the ISO as the CD drive. And just in case, I burnt everything to a DVD after modifying the configuration file.

I had no problems with the Windows upgrade, but after it rebooted, the AVG firewall wouldn’t start. The firewall reported the following error description:

Firewall cannot start because on error has occurred in communication with a driver. Please contact AVG Technical support.

Reinstalling AVG corrects the problem.

I’m now running the RTM of Windows 7 and I only had to reinstall AVG and VMware Workstation.

Override the connection string in IBatis.Net

Like many software developers, I built one too many data access layers. Don’t get me wrong – I’m really happy with ADO.Net and it’s capabilities. I just don’t want to write the same code snippets over and over. I’ve also gone the code-generation route using multiple tools like CodeSmith and even the Guidance Automation Toolkit. I’m a big fan of NHibernate and I’m looking forward to using it again in the future.

On my current project, we’re using IBatis.Net’s DataMapper.

For this project though, there was a slight twist. For security reasons, the connection string is encrypted - but not using the facilities to encrypt sections of the config file.  For whatever the reason, it is what it is.

Now, normally you would define your data sources in the SqlMap.config file. It would look something like this:

   1: <databases>

   2:     <provider name="sqlServer2.0"/>

   3:     <dataSource name="centralDb"

   4:         connectionString="server=(local); catalog=central;integrated security=true;persist security info=false;"

   5: </database>

This, of course, is not an encrypted connection string. It turns out that using an encrypted connection string with IBatis.Net really isn’t that difficult. We’ll start with out SqlMap.Config file.

Our SqlMap.config file

The only purpose of our file is to indicate that type of provider that we’ll be using. Notice that connection string contains information directing people to look elsewhere for it.

   1: <database>

   2: <provider name="sqlServer2.0">

   3: <datasource name="centralDb" connectionstring=" -- uses encrypted string from config file --">

   4: </database>


We have a custom DataSource that is responsible for retrieving the encrypted connection string, decrypting it and making it available.


   1: public class EncryptedDataSource : DataSource 

   2: { 

   3:     private IDataSource _innerDataSource; 

   4:     private string _connectionString; 

   5:     private object _lock = new object(); 


   7:     /// The data source. 

   8:     public EncryptedDataSource(IDataSource dataSource) 

   9:     { 

  10:         _innerDataSource = dataSource; 

  11:     } 


  13:     private void Initialize() 

  14:     { 

  15:         string encryptedConnectionString = ...; 


  17:         if (string.IsNullOrEmpty(encryptedConnectionString)) 

  18:         { 

  19:             throw new ConfigurationErrorsException( 

  20:             "The encrypted connection string could not be located within the configuration file. Please check the configuration file."); 

  21:         } 

  22:         this._connectionString = ...; // decrypt key 

  23:     } 


  25:     public override string ConnectionString 

  26:     { 

  27:         get 

  28:         { 

  29:             if (string.IsNullOrEmpty(this._connectionString)) 

  30:             { 

  31:                 lock (_lock) 

  32:                 { 

  33:                     if (string.IsNullOrEmpty(this._connectionString)) this.Initialize(); 

  34:                 } 

  35:             } 


  37:             return this._connectionString; 

  38:         } 

  39:         set 

  40:         { 

  41:             this._connectionString = value; 

  42:         } 

  43:     } 


  45:     /// 

  46:     /// The provider to use for this data source. 

  47:     /// 

  48:     public override IDbProvider DbProvider 

  49:     { 

  50:         get 

  51:         { 

  52:             return this._innerDataSource.DbProvider; 

  53:         } 

  54:         set 

  55:         { 

  56:             this._innerDataSource.DbProvider = value; 

  57:         } 

  58:     } 

  59: } 


We initialize our mapper as you would expect but we reset the DataSource with an instance of our EncryptedDataSource class. The constructor of the EncryptedDataSource accepts the data source that was built as part of the initialization. This way we can return it whenever the framework asks for information about the configured provider.

   1: protected static void InitMapper() 

   2: { 

   3:     ConfigureHandler handler = new ConfigureHandler(Configure); 

   4:     DomSqlMapBuilder builder = new DomSqlMapBuilder(); 

   5:     ISqlMapper mapper = builder.ConfigureAndWatch(_sqlMapFile,handler); 

   6:     Debug.Assert(null != mapper); 

   7:     mapper.DataSource = new EncryptedDataSource(mapper.DataSource); 

   8:     _mapper = mapper; 

   9: } 

Sunday, August 9, 2009

The Bass Guitar Build – Part 1

Two years ago I built my first guitar. Actually I rebuilt it. It was a guitar that my son had purchased from an amateur guitar builder. It was just an old guitar that had been painted to look like a Union Jack. I was interested in doing a project so I convinced my son to let me rebuild it. I stripped it all the way to the wood. Refinished it in white and replace all the hardware except for the pickups and tuners.

The big takeaway from that project: wiring is easy; refinishing is not.

This time my son proposed that we do a build together. He met a kid at Rock Camp that was interested in selling a Jackson Bass Guitar. The kid had stripped it down for parts. He was looking to sell the body and neck. It was in good shape except for some small chips and scratches.


The finish was in really good shape so I wanted to maintain it (remembering the lessons learned from the first build) .  I also liked the color which I think is Ruby Red. I wasn’t sure how to fix the chips and maintain the finish so we took the body to the local Rockler store to get some advice.

I went and talked to the associate that I had spoken with during the first build. He’s an excellent resource – having worked on guitars before.

Unfortunately his advice was it down to the wood. Not what I wanted to hear.

The Rockler associate then suggested that I take it to the local luthier.  Why hadn’t I thought of that?

(IMO, it’s a good idea to get to know you local luthier, especially if you’re just getting involved with guitars)

The luthier recommended using a touch-up paint on the chipped areas and then filling them in with Cyanoacrylate (CA). It can be applied in thin layers and then buffed to a shine.

Since one of the chipped areas was deeper than the others, I decided to fill it in a little with CA prior to painting it.


After a couple of layers, we primed the area with some primer that was left over from a previous project.


It’s common for guitar manufacturers to use automotive paint on their guitars. It shoots easy and is flexible. So my son and I grabbed the body and started visiting the local auto-parts stores in search for a touch-up paint that would match.

No luck.

The last store that we checked had a paint department that could do color matching. So I had the them run the process on the guitar and blend the paint for me. $12 got me a 2oz bottle of paint that was really close to the actual color. It turns out that red is difficult to match.


You can barely see it in the photo but the label contains the color components that went into creating the final color.

With the paint now in our possession, we could continue with the repairs to the body.


We applied a couple coats of paint. Remember that it’s better use a couple of thin layers than fewer thick one. When the paint was dry, we applied a couple layers of CA to bring the area flush.


When the CA was dry, we carefully sanded the area with some 1200 and 1500 grid sandpaper (I got mine from an auto-parts store. I’ve never seen anything that fine at a hardware store). Unfortunately the sandpaper dulled the shine in the surrounding area so I put my polishing wheel in the hand-drill and was able to restore the shine.

Here are before and after photos of one of the chipped areas.

P1000390 P1000407

It’s not perfect. The color turned out to be just a shade too dark but it’s better than what we started with.

Saturday, August 1, 2009

How I setup my GoDaddy domain with Blogger

This week I made the jump into the world of blogging. I decided that the easiest way to get started would be to register with and might as well register a domain also.

Then came the interesting part, connecting the two. Luckily Blogger actually makes this really easy and GoDaddy has an article on its help center called Mapping Your Domain to Work with Blogger Blog. I followed the directions and, like magic (DNS  magic??), both and lead to this blog.

But that’s not how I really wanted things to be configured. I really wanted the blog registered at and then have and the www subdomain redirect to This turned out to be really easy to accomplish.

  1. Follow the directions in this article but in the CNAMES section, create a “blog” record and direct it to
  2. Edit the “www” record (create one if there isn’t one) and direct it to “@” (without quotes).
  3. When configuring Forwarding, set the Forward to field to
  4. Within your Blogger account setup, set your custom domain to

After you’ve saved everything, it may take a couple of hours for the changes to take effect.