…but my budget told me I was getting a Kendal 899D.

I needed a hot air reflow tool more than anything. For my price point (that is, under $100), I had seen some reviews of the straight Hakko clones, but the remote pump and poor grounding practices I saw were just bad news. The Kendal is the type with a fan in the wand. This is a much simpler design in my opinion and I assumed much less prone to manufacturing shortcuts that would cause me reliability issues. But who knows.

The specs

• 700W Total power usage
• 100°C-480°C temperature selection on the hot air tool
• 100°C-480°C temperature selection on the soldering iron
• LED temperature display
• Blah, blah, blah just look at the pictures

You can pick these up on eBay for about $90 delivered, and I got mine from this eBay store. In general, make sure any tool you get on eBay is the 110V version.

What’s in the box

You get the basics:

• The main unit with attached hot air tool
• The detachable soldering iron
• An assortment of moderately useful soldering iron tips
• Three hot air nozzles
• A less useful “chip removing” tool or shrimp fork, I couldn’t tell

The unit fully assembled

The tools

Soldering tips

"Selection" of hot air tips

They claim this is a "chip remover"

The sticker on top is great:

Engrish is funny

Performance

To summarize: Works great.

Rework video

Ya, I want to dislike this thing, but it does its job like a champ. I’ll let the video do the talking.

The hot air tool has a reed switch that is used to turn it off when its in the holder. There’s a switch that turn off this feature, but I’ve really had no use for it in yet. It heats up fast, around 5 seconds to get to 360 from a cold start. After you put it back it blows air through it until it cools off. It’s not loud, but the fan does have an odd whirring noise. Either minor interference or a cheap bearing.

The iron is similarly fast in heating up, but the tips are not particularly optimal. There were issues where the long conical tip was too far from the heating element and putting it on the work just immediately cooled it off. Same with the hoof tip. You need to use some thought when working with these and give it a few seconds to recover between putting heat on the work. The rest of the tips aren’t of much use to me for a secondary iron.

There are a few other minor issues. The hot air tool, well, it gets hot. Uncomfortably hot if you work on things for a while. Nothing dangerous, mind you. Just not awesome. The manual looks like it was typeset by learning-disabled monkeys and is rife with poor sentence construction.  Also, the cords are shorter than I’d like.

Oh ya, and not anything to do with the tool, but hot PCBs look exactly like cold PCBs.

Sensor Design

If you want to use a capacitive touch interface in your AVR design, you’re either slogging through it for the learning experience, using a library from somebody who’s already done the slogging, or you’re using the Atmel QTouch libraries.

In particular, if you’re looking to do the rotary encoders, like the one on page 52 in the QTouch Sensor Design Guide, you will find yourself with a bit of an issue: they’re very difficult to draw.

Yep, large, curved polygonal regions with close gapping. Not fun. The only way to really do this correctly is to make it happen with software.

ULP Solution

So here you go, an Eagle ULP that draws these things:

#usage "<qt><nobr>This ULP calculates and place a rotary capacitive sensor.<p>"
       "<author>Author: Dan Afonso <dafonso@afonsoconsulting.com>, </author></nobr></qt>";
// THIS PROGRAM IS PROVIDED AS IS AND WITHOUT WARRANTY OF ANY KIND,
// EXPRESSED OR IMPLIED.
//Globals
string solderpoint      = "";
string file;
string s;  //temporary string
int c; // temporary counter
// Basic parameters
real outerRadius        = 30.0;
real innerRadius        = 15.0;
real bandMaximum        = 5.0;
int channels            = 3;
real channelGap            = 1;
real channelSpacing        = 4.5;
int debug                = 1;
real rad2deg            = 360/(2*PI);
// Converts from radial coordinates to Cartesian. This returns the X portion
real r2c_x(real r, real a, real o){
    return (r*cos(a)) + (o*sin(a));
}
// Converts from radial coordinates to Cartesian. This returns the Y portion
real r2c_y(real r, real a, real o){
    return (r*sin(a)) - (o*cos(a));
}
// The actual work.
void doIt(void){
    // Setup
    string cmd = "CHANGE WIDTH .5;\nGRID mm;SET WIRE_BEND 2;\n";
    real channelAngles[];

    // Figure out how wide our bands are going to be
    int bands = ceil((outerRadius - innerRadius)/bandMaximum);
    real bandWidth = (outerRadius - innerRadius)/real(bands);
    sprintf(s, "# Bands: %d, Band width: %.4f\n", bands, bandWidth);
    cmd += s;

    // Draw the tDocu layer

    sprintf( s, "Change layer %d;\n", 51);
    cmd += s;
    sprintf(s, "CIRCLE (0 0) (%.4f 0);\n", outerRadius);
    cmd += s;
    sprintf(s, "CIRCLE (0 0) (%.4f 0);\n", innerRadius);
    cmd += s;
    sprintf(s, "CHANGE WIDTH .1;\n");
    cmd += s;

    // Get our angles for the channels

    for (c = 0; c < channels; c++){
        channelAngles[c] = (c*2*PI)/real(channels);

        sprintf(s, "WIRE (%.4f %.4f) (%.4f %.4f);\n",
            r2c_x(innerRadius, channelAngles[c], 0), r2c_y(innerRadius, channelAngles[c], 0),
            r2c_x(outerRadius, channelAngles[c], 0), r2c_y(outerRadius, channelAngles[c], 0));
        cmd += s;
        sprintf(s, "WIRE (%.4f %.4f) (%.4f %.4f);\n",
            r2c_x(innerRadius, channelAngles[c], channelSpacing/2), r2c_y(innerRadius, channelAngles[c], channelSpacing/2),
            r2c_x(outerRadius, channelAngles[c], channelSpacing/2), r2c_y(outerRadius, channelAngles[c], channelSpacing/2));
        cmd += s;
        sprintf(s, "WIRE (%.4f %.4f) (%.4f %.4f);\n",
            r2c_x(innerRadius, channelAngles[c], -1*channelSpacing/2), r2c_y(innerRadius, channelAngles[c], -1*channelSpacing/2),
            r2c_x(outerRadius, channelAngles[c], -1*channelSpacing/2), r2c_y(outerRadius, channelAngles[c], -1*channelSpacing/2));
        cmd += s;

    }

    // and add band markings
    for (c = 0; c < bands; c++){
        sprintf(s, "CIRCLE (0 0) (%.4f 0);\n", innerRadius + c * bandWidth);
        if (c > 0) cmd += s;       
    }

    // OK, now to draw the polygons
    cmd += "CHANGE LAYER 1;\n";
    cmd += "CHANGE WIDTH .1;\n";
    real gap = channelGap / 2;
    real spacing = channelSpacing / 2;
    real arcAngle = channelAngles[1] * rad2deg;
    for (c = 0; c < channels; c++){
        // Add some clarity by defining these
        real channelAngleStart = channelAngles[channels - 1];
        if (c > 0) channelAngleStart = channelAngles[c - 1];
        real channelAngleStop = channelAngles[0];
        if (c < channels) channelAngleStop = channelAngles[c + 1];
        sprintf(s, "# Channel %d. %d Bands. Starts at (%.2f, %.1f) (with offsets) and goes from %.1f degrees to %.1f degrees\n",
            c + 1, bands, innerRadius, channelAngles[c] * rad2deg,  channelAngleStart * rad2deg, channelAngleStop * rad2deg);
        cmd += s;
        sprintf(s, "POLYGON (%.4f %.4f) -%2f ",
            r2c_x(innerRadius, channelAngles[c], /*gap - spacing*/0), r2c_y(innerRadius, channelAngles[c], /*gap - spacing*/0), arcAngle);
        cmd += s;
        for (int b = 0; b < bands; b++){
            real bandStart = innerRadius + (b * bandWidth);
            real bandEnd = bandStart + bandWidth;
            real bandMid = bandStart + (bandWidth / 2);
            // Draw the band
            sprintf(s, "(%.4f %.4f) +%.2f (%.4f %.4f) (%.4f %.4f) -%2f ",
                r2c_x(bandStart, channelAngleStart, 0 - spacing - gap), r2c_y(bandStart, channelAngleStart, 0 - spacing - gap), arcAngle,
                r2c_x(bandMid - gap, channelAngles[c], spacing - gap), r2c_y(bandMid - gap, channelAngles[c], spacing - gap),
                r2c_x(bandMid + gap, channelAngles[c], spacing - gap), r2c_y(bandMid + gap, channelAngles[c], spacing - gap),
                arcAngle);
            cmd += s;
        }

        // bring it around to the other side
        sprintf(s, "(%.4f %.4f) +%.2f (%.4f %.4f) +%.2f ",
            r2c_x(outerRadius + gap, channelAngleStart, 0 - gap - spacing), r2c_y(outerRadius + gap, channelAngleStart, 0 - gap - spacing),
            arcAngle,
            r2c_x(outerRadius, channelAngles[c], gap - spacing), r2c_y(outerRadius, channelAngles[c], gap - spacing),
            arcAngle
            );
        cmd += s;

        // Work our way in
        for (b = bands - 1; b >= 0; b--){
            real bandStart = innerRadius + (b * bandWidth);
            real bandMid = bandStart + (bandWidth / 2);
            // Draw the band
            sprintf(s, "(%.4f %.4f) -%.2f (%.4f %.4f) (%.4f %.4f)  +%.2f ",
                r2c_x(bandMid, channelAngleStop, gap + spacing), r2c_y(bandMid, channelAngleStop, gap + spacing), arcAngle,
                r2c_x(bandStart + gap, channelAngles[c], 0 - spacing + gap), r2c_y(bandStart + gap, channelAngles[c], 0 - spacing + gap),
                r2c_x(bandStart - gap, channelAngles[c], 0 - spacing + gap), r2c_y(bandStart - gap, channelAngles[c], 0 - spacing + gap), arcAngle
                );
            cmd += s;
        }
        // Close the arc
        sprintf(s, "(%.4f %.4f) ",
            r2c_x(innerRadius, channelAngles[c], /*gap - spacing*/0), r2c_y(innerRadius, channelAngles[c], /*gap - spacing*/0));
        cmd += s;
        cmd += ";\n";
    }

    // Add the pads
    for (c = 0; c < channels; c++){
        sprintf(s, "PAD 1.6764 round 'p%d' (%.4f %.4f)\n",
            c,
            r2c_x(innerRadius + 1, channelAngles[c], 0), r2c_y(innerRadius + 1, channelAngles[c], 0));
        cmd +=s;
    }
    // Finish up
    output(file, "wtD") printf("%s", cmd);
    sprintf(cmd, "SCRIPT '%s';", file);
    exit (cmd);
}
// *** main ***
// Setup
if (board) {
  board(B) file = filesetext(B.name, ".scr");
  solderpoint = ";\nVIA ";
}
else if (package) {
  library(L) file = filesetext(L.name, ".scr");
  solderpoint = ";\nPAD ";
}
else {
  dlgMessageBox("Start this ULP in a Board- or Package-Editor!", "OK");
  exit(0);
}
// Dialog
/*real bandMinimum        = 5.0;
real bandMaximum        = 8.0;
int channels            = 3;
real channelGap            = .1;
int debug                = 1;
*/
dlgDialog(filename(argv[0])) {
    dlgVBoxLayout {
        dlgLabel("<nobr> All measures in <b>mm</b> </nobr>");
        dlgGridLayout {
            dlgCell(0,0) dlgLabel("Outer Raidus");
            dlgCell(0,1) dlgRealEdit(outerRadius, 20.0, 100.0);
            dlgCell(1,0) dlgLabel("Inner Raidus");
            dlgCell(1,1) dlgRealEdit(innerRadius, 5.0, 30.0);
        }
    }
    dlgHBoxLayout {
        dlgPushButton("OK") {
            int ok = 1;

            if (innerRadius > (outerRadius - bandMinimum)){
                ok = 0;
                sprintf(s, "<qt>Inner Radius is too large");
                dlgMessageBox(s, "OK");
            }
            if (ok) {
                dlgAccept();
                doIt();
            }
        }
    }
};

Just run it and fill out the form while you’re in a library and it will do the dirty work. If the bits get too thin, it may drop some invalid polygon warnings. Be aware that you might need to manually fix these, or ignore them.

Potential Improvements

As I see it, there are some potential improvements to be made:

• The curve just uses a 120° arc, not the correct arc length as computer with the gaps. This leads to the odd bowing you see that becomes much clearer at smaller sizes.
• The outer ring needs a little indentation put in so that you can fit the curves a bit better.
• Option to use the alternate layout that Atmel recommends. The alternate layout is not symmetric, but does bring all three regions to the same place for easier routing .

Photo credits: QT600 kit, and sensor layout belong to Atmel, and I claim no ownership. Please don’t sue me.

Ingredients:

• 5.5Oz sugar (by weight)
• 1 Oz Honey (weight)
• 3 Oz ginger (weight)
• zest of a half a lemon
• 1/2 + 7.5 cups water
• 1/4 tsp baking yeast

Make syrup with sugar, honey, ginger and 1/2 cup water. Cover and bring to just a boil. Immediately take of the heat. Steep for 1.5 – 2 hours. Strain into a 2L growler or soda bottle, making sure to squeeze all the juice from the ginger pulp. Add 7.5 cups of water. When mixture is below 80 degrees F, add yeast, cap, and shake. Ferment for 2 days and put in fridge.

Serve on ice with Gosling’s dark rum and 1tbsp lime juice.

http://www.viddler.com/player/3658adf4/

A few things I do differently now:

• I know my toaster oven is slow, so rather than using a thermocouple, I just pop it in at 400F for 4 minutes, then jack it up to 450F and wait for the solder to turn shiny. This is a great help with tiny boards.
• Less paste is better. You can always add more after the fact.

My latest excuse was how difficult is was to press the kick drum pedal rapidly when you get tired. A real kick drum pedal requires very little force to activate and hold down, since they are effectively balanced and counter weighted systems that are very adjustable for response. Pedals shipped with any RockBand kit have no counterweight action and no bounce.

I have a Yamaha KP65 kick drum trigger that I use in a small MIDI kit. It feels surprisingly good for the price and is a world better than anything on the “fake” inputs that RockBand systems typically use. I figured I could rig a switch to make it contact the pedal when pressed down. I also figured that I’d have to do it on a time budget of about 4 hours or risk not getting something else done.

Long story short, double sided tape and a cheap micro switch were no match for Maps.

The Design

So, research time. I found some information on the RockBand forums with several circuits proposed. The first one I found used an op-amp (LM386) and a 555 to handle the transaction. This seemed reasonable at first but just looked more and more complicated as I thought about in. On page 11, someone posted a much streamlined circuit that had what I was looking for. However, this also seemed like it had a few too many parts, and frankly, I didn’t have that stuff lying around. I hate using 741s in battery circuits, which I did. I had some LMP2011 op-amps lying around, but at $2.75 each, I was not going to use two of them.

Effectively, this is just a circuit that amplifies the piezo output, detects the peak level, and shorts a signal to ground for a certain amount of time. My op-amp can run at 2 volts, but not more than 5.5V. Using a BJT to short the output seemed ineffective since they require more current to operate than a MOSFET… plus I have more MOSFETs around than BJTs. Finally, the diode selection was important. I prototyped with 1N4009, but the .6V drop limited sensitivity at the desired voltage ranges, so I figured that a Shottkey diode rated at about .2V would make this very sensative. I came up with this:

I’m using a 3V Lithium coin cell to drive this. The battery is good for 230mAh, and since this circuit has a quiescent requirement of 900µA, this should be more than enough for months of normal play.

I also didn’t feel the need to put in a sensitivity control. Most triggers have one already and getting the cutout on the case correctly with the parts I had was going to be a nightmare.

The Build

Every part specced is SMD, except the battery holder, which I was going to fake, regardless. The required board space is tiny, but the smallest case I could get in my time budget was RadioShack’s smallest one.I could make the board tiny and face it, or just make the board the right size to use the mounting holes.

I use Eagle. Because I’m too cheap to buy anything else, and don’t want to pirate stuff. Here’s what the board looks like in Eagle:

Here’s what it looks like in real life:

You can pick up a copy of the printable board template that I used.

For this version, I wound having to move the switch a bit in, and the board is clearly cut off on top. The scrap I had lying around was a smidge small.

Things I learned:

• Using a 20 Gauge dispensing needle rather than the normal 22 I use allowed me to move faster, but I hade 3 shorts on the board. Oops. There went the time budget.
• The hacked battery holder was good enough for a prototype.

Using it

Well, once I got the shorts cleared up I was very fortunate to find it worked straight away!

The signals looked good as well:

• First picture: The output from the front-end amp
• Second: Output from the peak detector to the MOSFET
• Third: The actual output (The crap at the end is due to a terrible rigging of the high-side resistor. It jiggled.)

Conclusions

Taking this for a quick spin made it obvious that it had worked quite well. It’s much easier to move fast and I didn’t see any extra hits or missed hits.

So, if I had to do it over again, I’d probably use a different op-amp. The Seiko S-89431 has the low voltage, rail-to-rail operation, and micro power that the LMP2011 gave me, and comes in around $.44 each in small quantities. I’ll try it at some point. Other than that, I think everything else was fine.