Spring is here, and that means it’s time to prepare for summer parties. If you’re me, that means making a ladder golf set. It seems like every year I’m making another one, the previous-year’s set having been gifted or left somewhere.

Over the years I’ve picked up a few tricks, and this time around I finally remembered to document them.

When making the bolas, I’ve found the through-hole method to be rock-solid and maintenance free. It took me a little while to find a painless way to crank these out.

I like to use a 1/4″ nylon rope and a 1/4″ hole, so stringing the rope can be difficult. My first trick is to taper the rope at the tip and tape it to something thin and rigid. Here I’m using a skewer, but I’ve used a piece of wire in the past.

The second trick is to put all the golf balls on the rope first, before double-knotting and cutting each bola.

The last thing I do on each bola is melt the end of the rope with an open flame, permanently locking the knot in place.

Making the ladder is straight-forward, so I won’t bother explaining that in detail. Two things I’ve learned though:

• You don’t need to use the purple pvc primer. This doesn’t have to be water tight, and the primer tends to run all over and makes things ugly
• A ratcheting tube cutter is worth every penny. It turns a long, messy job into a quick, clean one

I also tried something new this year. One of the things that bothered me about my previous ladders was the number of pieces. Each ladder breaks down into 3 pieces, which makes storage and transport a little annoying.

Using some of the left-over bola rope, I turned each ladder into a single unit with a shoulder strap. I’m pretty happy with how they came out, and with my design improvements.

One of my main issues was the size. I really wanted to make it smaller, but I didn’t want to pay for a small cartridge heater.

It occurred to me a couple of days ago that I might be able to modify a stock toaster-oven heating element to make a smaller heater. If I cut out a small section and drove it at a proportionally smaller voltage, I wondered, could I get a small heater with the same temperature as the big boy? It turns out that the answer is yes.

I went through a few fits and starts getting this thing to work. My main issue is that I’m still learning to weld, and welding wire requires a lot of finesse. I’m not going to bother with the trials and tribulations though. Here’s how I made a custom heating element:

Cut to Length

A heating element is a nichrome coil embedded in a steel tube using ceramic. In a toaster-oven they wire 2 in series, so each element is designed to see 60V. I had a 12V power supply, so I wanted to use 1/5 of the total element length. A pipe cutter made quick work of the cuts.

Ream

I needed to attach metal contacts to the wire. To give myself enough wire for a bond, and to have room to support the contact, some free space would be required. A metal file and some elbow grease left me with a 1/4″ cavity at each end of my cut section.

Weld

Attaching things to nichrome is a tricky proposition. Because it gets so hot you can’t use solder, and mechanical connections are unreliable. I decided TIG welding was the way to go.

Easy in theory, blindingly difficult (for me) in practice. In the end though, welding for 250mS at the lowest setting created a permanent bond bond between contact and wire.

Insulate

To keep this welded bond electrically isolated, and to give the contact some rigidity, I filled the previously-created cavity with furnace cement.

Next time around I might do this in several small additions rather than all at once. I think that would give me a more solid fill.

Burn Baby Burn

It actually works! I applied 12V to the element and was easily able to make some wood smoke. It didn’t get red-hot, but I suspect this is because my cut section was a bit long. At any rate, I’m really excited at the prospect of making inexpensive small heaters for use in my projects. I should probably get some more welding practice first though.

I needed a new scarf, and what I wanted I couldn’t buy. With a borrowed set of needles and some helpful internet videos, I cranked out a scarf in a couple of weeks.

Then something awful happened:  I enjoyed it.  For me, that means that I would have to keep doing it at least until I felt proficient.

This part of my personality can be really annoying sometimes, but I’ve learned it’s impossible to fight.  The quickest way to get stuff out of my system is to challenge the hell out of myself to quickly get to that proficient feeling.

So I decided I would make a hat. A difficult hat.  One that I definitely couldn’t buy.  It would be a multi-color hat with a custom pattern, allowing me to show off my love of oshw during the winter months.

Fair-isle

My first attempt at multi-color was using the fair-isle technique, whereby the unused colors are carried behind the knitting and occasionally wrapped in place.

I was ambitious, and went for a 3-color test pattern:

It turned out pretty well for a first try, but I didn’t particularly like the process or the end result.  Keeping track of 3 colors and wrapping was not enjoyable, and the final product felt pretty stiff.

Double knitting, Attempt #1

For the actual hat, I dropped my pattern down to two colors to improve the readibility of the image. I also settled on a different, double-knitting, technique. One of the benefits of double knitting is that it produces a reversible fabric, which you don’t see all that often.

Armed with my pattern and a 16″ circular needle, I got to work.  Once I got past the pattern I switched to double-pointed needles and reduced the hat by 6 stiches/row.  I was really happy with how everything turned out:

…until I tried it on.  It was too small, both in diameter and height.  I was able to make it fit on the dog though.

Double Knitting, Attempt #2

God I was pissed.  I added some length and width to my pattern.  To make sure I didn’t screw up the size on my second try I also got a 40″ circular needle.  I still used a 16″ for the main part of the hat, but I periodically threaded in the 40″ so that I could test-fit.

On the reduction section, a 40″ magic loop proved vastly superior to the double-ended needles.  I started by reducing 3 stitches a row, testing the fit every few rows.

Once I was near the top of my head I switched to 6 sticthes a row, closing off the hat.

I am very happy with the results:

And the good news is I don’t feel like I have to knit anymore.  I’ve found it to be a great activity while flying or riding in the car, so I might still dabble.  That crazy urge to get decent, however, seems to have been satiated.

A note about the pattern

For the fair isle pattern I was all proud of using various tricks in mspaint to make it. Then I discovered this method by Becky Stern:

It’s embarassingly better than my mspaint crap. For the double-knit pattern I used her method.  One thing I did differently was to use 10×6 pixel rectangles instead of squares.  I had found during a test swatch that my stitches were Wider than they were tall.  This modified grid ensured that the knit pattern would carry correctly.

While not nearly as in-depth, that’s the goal of this post. I’ll explain what the Autotune Library is trying to accomplish, and how it goes about its business.

Attribution

For A couple years I’ve wanted to have an Autotune Library, but due to an agreement with my employer, I wasn’t able to write one. BUT! when I found the AutotunerPID Toolkit by William Spinelli I was good to go; My company had no problem with me porting and augmenting and existing open source project.

I converted the code from matlab, made some tweaks to the peak identification code, and switched it from the Standard form (Kc, Ti, Td) to the Ideal form (Kp, Ki, Kd.) Other than that, all credit goes to Mr. Spinelli.

The Theory

The best tuning parameters (Kp, Ki, Kd,) for a PID controller are going to depend on what that controller is driving. The best tunings for a toaster oven are going to be different than the best tunings for a sous-vide cooker.

Autotuners attempt to figure out the nature of what the controller is driving, then back-calculate tuning parameters from that. There are various methods of doing this, but most involve changing the PID Output in some way then observing how the Input responds.

The method used in the library is known as the relay method. here’s how it works:

Starting at steady state (both Input and Output are steady,) the Output is stepped in one direction by some distance D. When the Input crosses a trigger line, the output changes to the other direction by distance D.

By analyzing how far apart the peaks are, and how big they are in relation to the output changes, the Autotuner can tell the difference between one type of process and another. As a result, different systems will get custom tuning parameters:

The Implementation

This works well in theory, but real-world data isn’t very cooperative. The input signal is usually noisy, which causes two main problems.

Problem #1: When to step?

Since a noisy signal is choppy, it’s likely that the trigger line will be crossed several times as the Input moves past it. This can cause mild chatter in the output, or if severe, can completely destroy things:

The way I chose to side-step this issue was to have the user specify a noise band. In effect, this creates two trigger lines. Since the distance between them is equal to the noise (if properly set) it’s less likely that multiple crossings will occur due to signal chatter.

Problem #2: Peak Identification

In a simulated world, identifying the peaks is easy: when the Input signal changes direction, that’s a minimum or a maximum (depending an which change occured.) In a noisy world however, this method fails:

Every noise blip is a direction change. To deal with this issue I added a “look-back time” parameter. It’s an awful name. If you can think of something better let me know.

At any rate, the user defines some window, say 10 seconds. The Library then compares the current point to the last ten seconds of data. If it is a min or a max, it gets flagged as a possible peak.

When the flagged point switches from being a max to a min, or vice versa, the previously flagged point is confirmed as a peak.

Another way of explaining the look-back time is that a point will be identified as a peak if it is the largest (or smallest) value within one look-back into the future or past. Like I said: awful name.

You should also know…

• The number of cycles performed will vary between 3 and 10. The algorithm waits until the last 3 maxima have been within 5% of each other. This is trying to ensure that we’ve reached a stable oscillation and there’s no external strangeness happening. This leads me to…
• I’m not the biggest fan of Autotune. I’ve often said, and still believe, that a moderately trained person will beat an Autotuner every day of the week. There’s just so much that can go wrong without the algorithm knowing about it. That being said, Autotune is a valuable tool to help the novice get into the ballpark.

I only started knitting recently. Something that’s been bothering me about it is the length of the needles. They’re 14″ long, and I’ve been worried they’ll be bent while riding in my backpack.

It occurred to me that some sort of collapsible needle might be useful in this situation. Taking my inspiration from elastic tent poles, I got to work on my “not PID” project.

construction

The first thing to do was cut the needles in half. I used a pipe cutter for a nice clean cut, then cleaned up the seam with a drill.

With the needles prepped, I then used a lathe to make the supporting inserts.

I didn’t quite get the diameter of the inserts right, so I touched things up at the sanding station.

To get some decent springiness, I looped 3 rubber bands together, then doubled that over. This was pulled through the insert and locked in place with a piece of paperclip. I then super-glued the insert into the pointed half of the needle.

The last thing to do was anchor the other end of the rubber bands in a hole drilled in the cap.

Results

I’m really happy with how these turned out. The weight increase was negligible, and the seam is almost invisible. It puts a slight drag on the yarn, but nothing major, and I haven’t had any hangs yet. Also, because the halves are connected, you can fold the needle with your knitting on it, without worrying that things are going to fall off.

They seem to be using a stand-alone commercial pid controller for at least some of the control. Perhaps this could be replaced with an osPID for a 100% open experience?

About 5 months ago I sent an out-of-the-blue email to RocketScream electronics asking if they wanted to help me build an open source PID controller. It’s been far more challenging than I expected, but today I get to announce the release of my first open source hardware project: the osPID!

(pause for applause)

The goal was to make an open equivalent to the PID controllers you can currently buy. To do this we combined the Arduino, my PID library, some open-source auto-tune code, and RocketScream’s Reflow Oven Controller Shield.

In some areas we fell short: The case, for example, isn’t nema rated. If this thing becomes popular however, there’s no reason we couldn’t fix that.

In some areas we hit our mark: form factor, interchangable I/O cards, Autotune, onboard user interface.

…And in some cases we hit out of the park: It has a java trending/configuration Application, and it costs… wait for it… $85.

I’m really proud of the work we’ve done, and there’s more to come. Let me leave you with some videos I created to help introduce this release.

Beginner:

Intermediate:

Hacker:

For more information check out the (slightly rough) website we’ve created at osPID.com/blog.

Enjoy!

As per the request by the Arduino Team, I’ve moved the Arduino PID Library to GitHub. I’ve also used this opportunity to:

• Make the Library Arduino 1.0 compliant
• Release the Library under a GPLv3 License

The google code site will still be there, but there will no longer be updates.

But I had to try. I had a great idea: a fairly understated bottle opener with different color text embedded on each side. To the uninitiated it’s a neat little thing, but to people who know 3D printing its a: “wait, what? how did you do that?”

Well, here’s “how I did that.” It took a LOT of time. I didn’t call it “The Saturday Killer” for nothing.

The Basic Idea:

Create a bottle opener with some multi-color text on the side. I chose a reference to the classic Simpsons line: “Beer. Cause Of. Solution To. Problems.” I knew it would be a complicated task, but it turned out to be even more complicated than I thought.

Step 1: Generate a separate STL for each color

Having already created the opener in OpenSCAD, this step was straight-forward. Position text on the sides (more on the font later,)

…use the Difference Command to create an opener with word holes,

…and use the intersection command to get a text object to fill each of those holes.

Step 2: Split each STL into printable segments

For the different colors to dovetail correctly, they can only be printed 2 layers at a time. To split the objects from step 1 into two-layer slices I used the difference command to remove all but a 2 layer section.


I then Generated an STL, moved the cubes, and repeated until I had all my slices.

Step 3: !#@$%@#$: Realize that this is way more complicated than you first thought.

Because you’re interlacing two or more STLs, how things are skeined becomes really important. If you’ve got a curve in the Z direction, or a transition that happens within a layer, things may skein one way for one color, but in a different way for the mating color.

So I needed to do a LOT more work, mainly on the text. I tried using a stock thingiverse font at first, but all the rounded corners were a killer, and I couldn’t get it to size correctly to an even number of layers. So I rolled my own:

If you look closely you’ll see that the text is blocky. This was done to confuse Skeinforge a little as possible. There are no diagonals or curves anywhere, and all transitions and openings take into account the layer thickness, as well as the width of the extrusion. This way there’s less confusion about how much plastic goes where, and the different colors are more likely to dovetail correctly.

Another thing that I added was a solid bar behind all the text. This caused the tool path to be much more continuous, resulting in nice, smooth letters.

Step 4: Actually Print

Now that all these parts were created they just needed to be printed out sequentially, with the Z-offset being adjusted at the appropriate time. My main aha moment during this process was that you need to turn off raft when skeining all but the first print, otherwise you get way too much plastic laid down.

I -of course- learned this the hard way. I first tried printing 4 openers at a time, and by the time I got to the middle of the opener there was so much plastic that the extruder started to catch leading to misalignment.

I scrapped that print and started printing a single opener, realizing the raft thing just after I started. The results were much better:

Step 5: Enjoy

I’m really proud of this thing, but I spent WAY too much time creating it. Hopefully this quick post did a good-enough job of explaining the process. I wanted to share this project, but for my sanity I just need to be DONE.

opener: http://www.thingiverse.com/thing:12592
font: http://thingiverse.com/thing:12618

Up to this point, all my openers have been single color. But combine the fact that I’m jealous of the new dual extruder with the fact that Matt was my Best Man, and I decided that this time I would go the extra mile.

The procedure was straight-forward, and a huge pain in the butt:

• First I printed a blank opener in the base color
• Then I adjusted the Z-Height of the Thingomatic by 5.76mm (the height of the opener base)
• When I switched the color to blue and printed the tail, the printer deposited the plastic on the white base as if it were the build platform
• After switching colors AGAIN, I printed the W and the opener was done

This was a fairly simple multi-color design, but by breaking up the model ahead of time, this technique could be used for any part.