All posts by Takaitra

About Takaitra

Matthew is a software engineer for Amazon's Cloud Drive team working with various technologies including web services, React Native and Android. His interests include motorcycling, camping, photography, small electronics and traveling. He lives in Seattle, Washington with his beautiful wife and two children.

Fractal Design R4 Headphone Jack Repair (USB-70A AZALIA)

I’ve been using the Fractal Design R4 PC case for a number of years now. I love the design but the placement of the headphone jack leaves something to be desired. It is oriented vertically meaning that pulling on the headphone cable can easily break the port which unfortunately happened to me. Removing the front panel of the case reveals a small circuit board labeled “USB-70A AZALIA REV: A1”.

The circuit board with damaged headphone jack

Not designed with toddlers in mind

A quick search showed me that it’s not easy to find a replacement for this part so I decided to write up how it can be repaired.

The board consists of two headphone jacks and a pin header. The broken headphone jack needed to be replaced. The first step is finding the correct replacement part. Some searching reveals the CP1-3525NG-ND on Digi-Key. I always order inexpensive parts in multiples of 10 to get the price break and because it’s good to have spare parts around for future projects.

A handsome array of headphone jacks

Using a soldering iron, heat up and remove as much of the solder around the pins of the headphone jack as possible. I didn’t have much luck with soldering wick but a soldering vacuum worked well. A trick is to add a small amount of solder to the tip of the soldering iron to help quickly heat the solder in the joint.

After removing the solder, gently remove the old headphone jack.

PCB after removing the broken headphone jack

Solder the replacement headphone jack into place. Heat the pin using the iron and apply enough solder so that it flows into each via.

I ended up replacing both jacks because the replacements have a metal ring that looks more sturdy than the original.

PCB with replacement headphone jacks

Both my headphones and a microphone worked great after putting everything back together. I was initially worried that the pinout of the replacement jacks might be different than the originals but they turned out to be an exact match.

Running Python CGI Scripts on the Raspberry Pi

Python is the language of choice for controlling the Raspberry Pi’s GPIO pins. It seems only natural then that to interact with your Pi over the web it should run a web server able to handle Python CGI scripts. Following the steps below will get the lightweight nginx web server running on your Pi, handing Python requests off to a uwsgi helper process.

  1. Install nginx
    sudo apt-get update
    sudo apt-get upgrade
    sudo apt-get install nginx
  2. Add a location to the /etc/nginx/sites-available/default to pass Python requests on to uwsgi. This needs to be placed inside the “server” block of the configuration, for example right after one of the existing “location” sections.
    location ~ \.py$ {
    include uwsgi_params;
    uwsgi_modifier1 9;
  3. Create a Python CGI script at /usr/share/nginx/www/
    #!/usr/bin/env python
    print "Content-type: text/html\n\n"
    print "<h1>Hello World</h1>"
  4. Start nginx
    sudo /etc/init.d/nginx start
  5. Build and install the uwsgi with the cgi plugin
    curl | bash -s cgi /home/pi/uwsgi
    sudo mv /home/pi/uwsgi /usr/local/bin
  6. Create the file /etc/uwsgi.ini
    plugins = cgi
    socket =
    module = pyindex
    cgi = /usr/share/nginx/www
    cgi-allowed-ext = .py
    cgi-helper = .py=python
  7. Create the file /usr/share/nginx/www/
    #!/usr/bin/env python
    print "Content-type: text/html\n\n"
    print "<h1>Hello World</h1>"
  8. Create an init script for uwsgi at /etc/init.d/uwsgi
    #!/bin/sh### BEGIN INIT INFO
    # Provides: uwsgi
    # Required-Start: $local_fs $remote_fs $network $syslog
    # Required-Stop: $local_fs $remote_fs $network $syslog
    # Default-Start: 2 3 4 5
    # Default-Stop: 0 1 6
    # Short-Description: starts the uwsgi cgi socket
    # Description: starts uwsgi using start-stop-daemon
    test -x $DAEMON || exit 0
    set -e
    . /lib/lsb/init-functions
    case "$1" in
    echo -n "Starting $DESC: "
    start-stop-daemon --start --quiet --pidfile /var/run/$ \
    --make-pidfile --chuid www-data --background \
    --exec $DAEMON -- $DAEMON_OPTS || true
    echo "$NAME."
    echo -n "Stopping $DESC: "
    start-stop-daemon --stop --quiet --pidfile /var/run/$ \
    --exec $DAEMON || true
    echo "$NAME."
    echo -n "Restarting $DESC: "
    start-stop-daemon --stop --quiet --pidfile \
    /var/run/$ --exec $DAEMON || true
    sleep 1
    start-stop-daemon --start --quiet --pidfile /var/run/$ \
    --chuid www-data --background \
    --exec $DAEMON -- $DAEMON_OPTS || true
    echo "$NAME."
    status_of_proc -p /var/run/$ "$DAEMON" uwsgi && exit 0 || exit $?
    echo "Usage: $NAME {start|stop|restart|status}" >&2
    exit 1
    exit 0
  9. Start uwsgi and configure it to start on boot
    sudo chmod +x /etc/init.d/uwsgi
    sudo /etc/init.d/uwsgi start
    sudo update-rc.d uwsgi defaults
  10. Open up your web browser and go to http://{your pi’s ip address}/
    If you’re using the browser on your Pi then you could instead go to http://localhost/
    If you see the message “Hello World” then everything is working.

Controlling the MCP4151 Digital Potentiometer with the Raspberry Pi

We’re going to use the Raspberry Pi’s SPI bus to control Microchip’s MCP4151 8-bit digital potentiometer.  The MCP4151 is an 8 pin SPI device that can be used to programmatically control output voltage. The GPIO pins on the pi run at 3.3 volts meaning that we can command the pot to output between 0 and 3.3 volts. However, if we instead power the pot with 5 volts then we can control a voltage between 0 and 5 volts. Note that PWM is a possible alternative to a digital pot that doesn’t require an extra chip. However, this can add  noise to the signal that wasn’t acceptable for my project.

Microchip’s datasheet is recommended reading before starting this project.

Parts List

Step 1: Configure SPI on the Raspberry Pi

Follow the first two steps in Controlling an SPI device with the Raspberry Pi.

Step 2: Wire up the components

Being a pin-limited device, the SPI input and output on the MCP4151 shares one pin. That’s not a problem in our case since we’re only interested in writing to the device.

You’ll notice that we’re powering the pot with 5 volts despite the Raspberry Pi being a 3.3 volt device. This is fine because 1) The Pi sends commands to the pot but receives nothing back. Therefore, there is no risk of overvoltage on the Pi’s pins. And 2) The pot recognizes any SPI input over 0.7 volts as a high signal. This means the 3.3 volts from the Pi is plenty to communicate with the pot.

digital pot

As you can see, the power, ground and the SPI signals take up most of the pins. The actual potentiometer terminals are pins 5, 6 and 7.

Pin Description
1 SPI chip select input
2 SPI clock input
3 SPI serial data input/output
4 Ground
5 Potentiometer terminal A
6 Potentiometer wiper terminal
7 Potentiometer terminal B
8 Positive power supply input



Step 3: Create the python script

To test out the device, we’re going to continuously loop through all the possible values for the potentiometer. This will cause the voltage at the wiper terminal grow and shrink between 0 and 5 volts. Create the following script on your Pi.


import spidev
import time

spi = spidev.SpiDev(), 0)
spi.max_speed_hz = 976000

def write_pot(input):
    msb = input >> 8
    lsb = input & 0xFF
    spi.xfer([msb, lsb])

while True:
    for i in range(0x00, 0x1FF, 1):
    for i in range(0x1FF, 0x00, -1):

Step 4: Run the script

Make the script executable and run it with the following commands.

chmod +x
sudo ./

If all goes well, you should see the LED continuously fade to full brightness then off again.

Controlling an SPI device with the Raspberry Pi

The Raspberry Pi has a Broadcom BCM 2835 chip allowing it to interface with SPI devices on its GPIO pins. There are two chip select pins meaning that the Pi can control two devices simultaneously.

P1 Header Pin Function
19 MOSI – master output slave input
21 MISO – master input slave output
23 SCLK – clock
24 CE0 – chip enable 0
26 CE1 – chip enable 1

Step 1: Enable SPI on the Raspberry Pi

  1. In your Pi’s terminal, run
    sudo raspi-config
  2. Go to Advanced Options > SPI
  3. Choose “Yes” for both questions then select Finish to exit raspi-config
  4. Either reboot your Pi or run this command to load the kernel module
    sudo modprobe spi-bcm2708

Step 2: Install spidev

Spidev is a python module that allows us to interface with the Pi’s SPI bus.Watch movie online The Transporter Refueled (2015)

sudo apt-get update
sudo apt-get upgrade
sudo apt-get install python-dev python3-dev
cd ~
git clone
cd py-spidev
sudo make install

Step 3: Python script

Finally, we can write and run a python script to control the SPI device.

  1. Create a file called in your favorite editor
    import spidev
    import time
    spi = spidev.SpiDev(), 0)
    spi.max_speed_hz = 7629
    # Split an integer input into a two byte array to send via SPI
    def write_pot(input):
        msb = input >> 8
        lsb = input & 0xFF
        spi.xfer([msb, lsb])
    # Repeatedly switch a MCP4151 digital pot off then on
    while True:
  2. Make the file executable and run it
    chmod +x
    sudo ./

Notes on spidev

Unless the spi.max_speed_hz field is a value accepted by the driver, the script will fail when you run it. The field can be set to these values on the raspberry pi:

Speed spi.max_speed_hz value
125.0 MHz 125000000
62.5 MHz 62500000
31.2 MHz 31200000
15.6 MHz 15600000
7.8 MHz 7800000
3.9 MHz 3900000
1953 kHz 1953000
976 kHz 976000
488 kHz 488000
244 kHz 244000
122 kHz 122000
61 kHz 61000
30.5 kHz 30500
15.2 kHz 15200
7629 Hz 7629

Two SPI devices can be controlled in python by creating two SpiDev objects, one for each device.

spi = spidev.SpiDev(), 0)
spi.max_speed_hz = 976000

spi2 = spidev.SpiDev(), 1)
spi2.max_speed_hz = 976000

Manual WordPress Upgrade – The Easy Way

I choose to not run FTP on my server so when it comes time to upgrade WordPress, I do it manually. If, like me, you think that even the short instructions are too long, here are the even shorter instructions. These commands are done within an SSH shell on the server.

  1. Backup your existing WordPress install and database
  2. Download WordPress and upgrade using the below commands. Replace the directories with those specific to your system.
    cd ~/downloads
    tar xvzf latest.tar.gz
    cd /var/www/wordpress
    rm -r wp-includes wp-admin
    cp -r ~/downloads/wordpress/wp-includes .
    cp -r ~/downloads/wordpress/wp-admin .
    rsync -rAv ~/downloads/wordpress/wp-content/ wp-content/
    rsync -Av ~/downloads/wordpress/*.{php,html,txt} .
  3. Visit your main WordPress admin page at /wp-admin and upgrade the database if necessary.

Motorcycle Garage Door Opener

In the past it was a hassle to get off of my motorcycle to key in the garage door code before getting back on the cycle to pull it into the garage. Stashing a garage door opener in my jacket pocket was a little better but I still had to stop to take off my motorcycle gloves. My solution was to hack a garage door opener to activate via a switch on my handle bar. Because I do almost all of my riding in the city, I never use my passing switch so this was the one I chose to tap into. The following is a guide of how I did it and was done for a LiftMaster opener/remote. The same concepts should apply to other brands but I have not tried them.


  • A LiftMaster garage door remote. Make sure you get the correct remote for your opener (based on whether the learn button on your opener is red-orange or purple ). I used the remote with only one button to keep things simple.
  • A TO-92 (3 pin through hole) NPN transistor. I bought a pack of these from RadioShack. The specific one I used is KSP2222A but there are many equivalent part numbers that will work.
  • A 2.7M Ohm 1/4 watt resistor. If you can’t find this exact one, any resistor near this value should work. I bought a huge variety pack of resistors that included this one on eBay for only a few bucks.
  • Red and black small gauge stranded wire
  • A wiretap connector to tap into your motorcycle’s switch


  • Soldering iron
  • Flush/diagonal cutter for trimming the transistor leads
  • Solder sucker or copper braid to remove the solder from the remote’s button
  • Something to notch the side of the remote. A dremel tool works well for this.

Step 1: Remove the Push Button Switch

If you haven’t already, don’t program your remote for your opener yet. You don’t want to accidentally be opening and closing your garage door while working on this project. Begin by opening up the case of your remote and removing the circuit board.

The remote with the case opened
The remote with the case opened

You’ll see a small black and silver momentary push button switch near the bottom. Pressing down on this switch completes a circuit which activates the opener. We want to remove the switch so that we can replace it with a transistor activated by a 12V signal from the bike. Use your soldering iron and solder sucker or copper braid to remove the solder from the pins of the button.

Removing the solder from the button's pins
Removing the solder from the button’s pins

After the solder is removed, the button will easily come off of the board.

Circuit board with the button removed
Circuit board with the button removed

Step 2: Solder the transistor

Next we need to replace the button with the transistor. The transistor acts as an electronic switch. When the base of the transistor is activated by the 12 volts from the motorcycle, it will allow current to flow from the collector to the emitter. Bend up the middle lead of the transistor and insert the other two leads into the circuit board. Make sure it matches the orientation shown in the photo.

The circuit board with transistor
The circuit board with transistor

Then solder and trim the leads on the reverse side of the board.

The transistor leads soldered and trimmed
The transistor leads soldered and trimmed

Step 3: Add the Resistor

Only a very small current is needed for the remote’s circuit to consider our new switch “closed.” We’re going to solder a resistor to the base of the transistor to make sure we don’t damage it when we send it 12 volts from the motorcycle. Clip the leads short on the resistor and solder it to the remaining transistor lead.

Ready to solder the resistor with a helping hand.
Ready to solder the resistor with a helping hand.

Step 4: Solder signal and ground wires

Cut a couple feet of red and black wire and strip the ends. Solder one end of the red wire to the end of the resistor.  Solder one end of the black wire to the circuit board as shown.

LiftMaster PCB
The Modified LiftMaster PCB

Step 5: Modify the case

You’ll need to cut a couple notches into the garage door opener’s case where the wires will come out. I believe I used a dremel tool for this. When you’re done, thread the wires through the notches, and snap the circuit board back into its case.

The notched opener case.
The notched opener case.

Modified LiftMaster
With the modifications to the LiftMaster garage door opener complete, it’s ready to install on the motorcycle.

Step 6: Program and test the remote

For this step you need access to a 12 volt power source–the terminals of your motorcycle’s battery will work in a pinch. To program the remote, tap the orange or purple learn button on your opener then hold the red wire to the positive terminal on the battery and the black wire to the negative terminal for a few seconds. Your garage door light should blink when the programming is complete.

Now disconnect the remote then connect it once more. If your garage door activates, it’s working!

Step 7: Install opener on motorcycle

This is where you get to be a bit creative. I chose to tap the red signal wire into the high beam wire on my SV650, allowing me to use my passing signal to trigger the garage door opener. To do this, I made a small cut to get into the wire bundle near my steering column then used the posi-tap connector to make the connection. I then wrapped the bundle back up with electrical tape. You can either connect the ground to a ground wire on your motorcycle or to any metal part of the frame. I chose to screw it down using the screws holding down my gas tank.

Finally, you’ll need a place to stash the remote. On my SV650, I found that there was extra space underneath my gas tank in front of the airbox.

I forgot to take pictures of this step but if you think it’d be helpful let me know and I’ll post some. Have fun and enjoy your motorcycle’s new garage door opening abilities!

Automating Rsync Backups to Amazon EC2

A while back I wrote about how to perform incremental backups via rsync to an Amazon EC2 instance. The script worked great when run manually from a Python interpreter but I always ran into issues when trying to automate the script via cron. I finally took some time to hammer out all of the automation issues and fixed some other bugs along the way. With the new fixes in place, I now have my VPS automatically backed up nightly via cron, all for about $1/month!

For the backup script including the latest updates, take a look at my Backup to AWS EBS via Rsync and Boto how-to. I’ve documented the problems encountered and how I fixed them below.

Preserve File Ownership in the Backup

I learned that the remote rsync process must run as root in order to preserve file ownership. This is accomplished by adding –rsync-path=”sudo rsync” to the rsync command. However, EC2’s Amazon Linux AMI does not allow this by default because it requires a tty (terminal) to run a sudo command. The solution was to add a line to the script that ssh’s into the EC2 instance, forces allocation of a pseudo-tty, then appends “Defaults !requiretty” to /etc/sudoers.

Maintain Proper Directory Structure in the Backup

Another issue I discovered was that my backup was getting created with directories like /home/home/username/ instead of /home/username/. The solution to this was to simply ensure that all of my rsync destinations contained a final trailing slash.

Connection Denied for SSH

This was the error I saw that was preventing me from running the script via cron. Putting the script to sleep for 60 seconds after attaching the volume fixed this.

Terminate the EC2 Instance when Finished

The original script stopped the EC2 instance rather than terminating it. The EC2 instance is only needed for the rsync after which it should be terminated in order to avoid extra fees from AWS! The backed up data will remain on the detached EBS volume even after the instance is terminated.

Backup to AWS EBS via Rsync and Boto 3

Update 11/2015:

  • Updated the script to use boto3 and waiters
  • Switched to use the t2.micro instance type with VPC
  • More detailed setup instructions


Amazon Web Services Elastic Block Storage provides cheap, reliable storage—perfect for backups. The idea is to temporarily spin up an EC2 instance, attach your EBS volume to it and upload your files. Transferring the data via rsync allows for incremental backups which is very fast and reduces costs. Once the backup is complete, the EC2 instance is terminated. The whole process can be repeated as often as needed by attaching a new EC2 instance to the same EBS volume. I backup 12 GB from my own server weekly using this method. The backup takes about 5 minutes and my monthly bill from Amazon is around $1.

Setup Your VPC

You’ll need an AWS VPC with access to the internet. Exactly how to do this is beyond the scope of this article but you should basically follow AWS’ instructions for creating a “VPC with a Single Public Subnet”. Also make sure that
  1. The default security group for your subnet allows inbound port 22 (SSH) and inbound port 873 (rsync)
  2. Your subnet has “Auto-assign Public IP” enabled
  3. You create an EBS volume in your preferred zone (location). Make sure it is large enough to store your backups.

Create Your Access Key and Key Pair

Create an Amazon EC2 key pair. You need this to connect to your EC2 instance after launching it. Download the private key and store in on your system. In my example, I have the private key stored at /home/takaitra/.ec2/takaitra-aws-key.pem Also create an access key (access key ID and secret access key) for either your root AWS account or an IAM user that has access to create instances. Make sure to save your secret key somewhere safe as you’ll only be able to download it once after creating it. I had problems using a key that had special characters (=, +, -, /, etc) so you may want to regenerate your key if it has these in it.

Install and Configure Boto 3

Assuming you have Python’s pip, installing Boto 3 is easy.
$ pip install boto3
The easiest way to set up your access credentials is via awscli.
$ pip install awscli
$ aws configure
AWS Access Key ID: [enter your access key id]
AWS Secret Access Key: [enter your secret access key]
Default region name: [enter the region name]

The Script

The below script automates the entire backup process via Boto (A Python interface to AWS). Make sure to configure the VOLUME_ID, SUBNET and BACKUP_DIRS variables with your own values. Also update SSH_OPTS to point to the private key of your EC2 key pair.
#!/usr/bin/env python

import os
import boto3
import time

IMAGE           = 'ami-60b6c60a' # Amazon Linux AMI 2015.09.1
KEY_NAME        = 'takaitra-key'
INSTANCE_TYPE   = 't2.micro'
VOLUME_ID       = 'vol-########'
PLACEMENT       = {'AvailabilityZone': 'us-east-1a'}
SUBNET          = 'subnet-########'
SSH_OPTS        = '-o StrictHostKeyChecking=no -i /home/takaitra/.ec2/takaitra-aws-key.pem'
BACKUP_DIRS     = ['/etc/', '/opt/', '/root/', '/home/', '/usr/local/', '/var/www/']
DEVICE          = '/dev/sdh'

print 'Starting an EC2 instance of type {0} with image {1}'.format(INSTANCE_TYPE, IMAGE)
ec2 = boto3.resource('ec2')
ec2Client = boto3.client('ec2')
instances = ec2.instances.filter(
    Filters=[{'Name': 'instance-state-name', 'Values': ['pending']}])
instanceList = list(instances)
instance = instanceList[0]

print 'Waiting for instance {0} to switch to running state'.format(
waiter = ec2Client.get_waiter('instance_running')
print 'Instance is running, public IP: {0}'.format(instance.public_ip_address)

    print 'Attaching volume {0} to device {1}'.format(VOLUME_ID, DEVICE)
    volume = ec2.Volume(VOLUME_ID)
    print 'Waiting for volume to switch to In Use state'
    waiter = ec2Client.get_waiter('volume_in_use')
    print 'Volume is attached'

    print 'Waiting for the instance to finish booting'
    print 'Mounting the volume'
    os.system("ssh -t {0} ec2-user@{1} \"sudo mkdir /mnt/data-store && sudo mount {2} /mnt/data-store && echo 'Defaults !requiretty' | sudo tee /etc/sudoers.d/rsync > /dev/null\"".format(SSH_OPTS, instance.public_ip_address, DEVICE))

    print 'Beginning rsync'
    for backup_dir in BACKUP_DIRS:
            os.system("sudo rsync -e \"ssh {0}\" -avz --delete --rsync-path=\"sudo rsync\" {2} ec2-user@{1}:/mnt/data-store{2}".format(SSH_OPTS, instance.public_ip_address, backup_dir))
    print 'Rsync complete'

    print 'Unmounting and detaching volume'
    os.system("ssh -t {0} ec2-user@{1} \"sudo umount /mnt/data-store\"".format(SSH_OPTS, instance.public_ip_address))
    print 'Waiting for volume to switch to Available state'
    waiter = ec2Client.get_waiter('volume_available')
    print 'Volume is detached'
    print 'Terminating instance'


Follow these steps in order to automate backups to Amazon EC2. The steps may vary slightly depending on which distro you are running.
  1. Save the script to a file without a file extension such as “ec2_rsync”. Cron (at least in Debian) ignores scripts with extensions.
  2. Configure the script as explained above.
  3. Make the script executable (chmod +x rsync_to_ec2)
  4. Check that the script is working by running it manually (./ec2_rsync). This may take a long time if this is your initial backup.
  5. Copy the script to /etc/cron.daily/ or /etc/cron.weekly depending on how often you want the backup to run.
  6. Profit!

VelocityEmail – Easy E-mail for Java using Templates

A common requirement for a Java web application is that it be able to send e-mail in response to certain events. A couple simple examples of this requirement are a web form that sends a confirmation e-mail to the user and sending automated messages when exceptions occur. These e-mails must often incorporate dynamic content. In the web form example, content from the form submission could be included in the confirmation e-mail.

VelocityEmail extends the Email class from Commons Email to provide an elegant solution to this problem. The simplicity of Commons Email makes constructing and sending the e-mail a breeze while Velocity templates allow the content to be completely flexible and dynamic. The most important benefit of this approach is that it allows separation of the e-mail content from the project code, greatly increasing maintainability.


The latest release is VelocityEmail 1.0


How to Use VelocityEmail

  1. Create HTML and/or plaintext Velocity templates for your email. By
    default, you can reference any fields of your soon-to-be merged javabean
    like $bean.fieldName. Place the templates in your project’s source folder or
    wherever they’ll be available on the classpath.
  2. Create an instance of VelocityEmail, passing the the template filename to
    the constructor and initialize it as you would normally initialize an

     VelocityEmail email = new VelocityEmail(templateName);
  3. Merge the javabean with the template by using the appropriate
    setHtmlMsg() and setTextMsg() methods. 


    OR, if you have multiple javabeans, you may create your own VelocityContext and pass that in instead.

     VecocityContext context = new VelocityContext();
     context.put("bean1", javabean1);
     context.put("bean2", javabean2);
  4. Send the email.