Monday, August 22, 2016

A free band saw

Thanks to my wife's keen eye on our neighborhood message board, I just scored a FREE band saw.  It seems that someone was cleaning out their garage and just wanted to get it out of their ASAP.  It's a Craftsman 12" band saw from the 80s.

Check out the pictures below.  It needs one new tire and a new table insert (which I might be able to make myself).  It seems like the bearings are in good shape, the tensioner works, and the motor runs.  So after some cleaning, lubricating, adjusting, and $30-40 in parts it should be in good shape again.

This is after I brushed off the loose dirt and cobwebs

It's dirty, a little rusty, and several generations of
wasps have lived in there, but the bones looks
pretty good.

The motor pulley and belt need to be re-attached.  No biggie.

This is probably the biggest issue (which still isn't bad).  The
top wheel needs a new tire since a section of it is missing.

Monday, August 15, 2016

Sharpening old tools

If you thought, based on the title of this post, that I'd be discussing refreshing some previously learned skills, you may be disappointed.  Instead I'll actually be showing off how I sharpened some vintage woodworking tools.

I've recently been re-discovering my woodworking hobby, while learning to use hand tools in place of the power tools I've previously used.  There are many reasons I've decided to use less electricity to make wooden objects, but I'll save all of that for another post.  I'll just focus on sharpening for now.

Rough Grinding
Usually you start sharpening by rough grinding the bevel angle on the blade.  This step is only required if you are setting a new bevel angle or if the blade is otherwise damaged.  You can do the rough grinding by hand but I opted to use a power grinder with a 40 grit grinding wheel.  So I lose some hand tool merit points for using electricity here.  All of the blades I sharpened were to 25 degrees, which is pretty standard.

Honing Methods
There are tons of ways to sharpen metal blades: oil stones, water stones, diamond plates, etc.  I'll be using a lesser-known method: sand paper.  I learned about using sand paper from the Naked Woodworker, but there are many people that prefer this method, often known by the name Scary Sharp.

The basic requirements are three or four grits of sand paper going from around 150 grit up to 800 or 1000.  Spray adhesive (or similar) is used to attach the sand paper to a flat surface like plate glass.  When I went to the Home Depot to get supplies they only had very thin window glass, and I wanted something thicker.  I was impatient so rather than waiting to go to a glass shop, I looked around in the tile section and found a large floor tile that was dead flat (I checked it with a straight edge).  I haven't heard of anyone using floor tiles before but I can't think of a reason it shouldn't work.

With any of these methods it's common to use a honing guide to keep the angle, though some people like to freehand the bevel angle once it's been rough ground.  I used two different honing guides, an Eclipse and a Veritas.

The Block Plane
The first thing I tried to sharpen was an old Craftsman block plane (circa 1920). It was the first time I've use a grinder and I had a little trouble getting the tool rest set to the right angle.  The end result is that the blade has two bevel angles as you can see in the photo below.  Functionally it works fine, even if it's a little ugly, and after honing I can shave with it.

I tested the plane out by cutting some end grain bevels (something a block plane is ideal for).  It seemed to perform pretty well even while taking a pretty aggressive cut.

The Smoothing Plane and Chisels
Next up was a nice Millers Falls Smoothing Plane.  This one was straight-forward except that whoever had previously sharpened it had kind of messed it up and put quite a bit of skew on the blade (maybe it was intentional).  I ground off the skew and made it straight across again.  I also knocked down the corners of the blade a little to reduce tear out.  After honing I was able to take paper-thin shavings which is what you need in a smoothing plane.

I also sharpened some chisels, but they were brand new and factory ground to 25 degrees to they just required a quick honing.  I didn't even get any pictures of the chisels.

The Jack Plane
I left the most difficult one for last.  A jack plane is usually used for taking off lots of wood quickly.  To optimize for this the blade geometry needs a little curve, which is called camber.  Although the curvature is slight this allows the plane to scoop the wood out and take off much larger chips.  This is really useful if the wood is twisted or cupped and you need to take off an eighth of inch or so.

I wanted to take about a sixteenth of an inch off of each corner, and beyond that I just planned on free-handing it on the grinder. I got a tip from watching some YouTube videos that it easiest to take the corners off by putting the blade into the wheel at 90 degrees and then once the curve is ground the same 25 degrees bevel is established all the way across.  It took a while but I eventually got the camber you can see below.

Honing a cambered blade was a little trickier than a straight blade, since you need to sort of lean the blade back and forth as you hone.  For this I used the eclipse guide since it has a small wheel that lets you lean the guide much easier than the Veritas guide.

To test I took a fairly conservative cut, and although it may be hard to see in the photo below, it took some quite thick chips.  It was interesting that I could feel the camber of the blade in the chips, in that they were quick thick in the middle but got paper thin at the edges.

Saturday, August 13, 2016

LabVIEW for BBB and RPi Internals: Yocto, chroot, and other strange words

I recently helped create a toolkit to allow running LabVIEW VIs on a BeagleBone Black (BBB) or Raspberry Pi 2 (RPi2).  In this post I'd like to get into some of the technical challenges we encountered along the way.

SamK, the author of the LINX toolkit, took over creating the LabVIEW I/O library.  LINX was originally written to allow LabVIEW to easily access the I/O on Arduinos and similar devices, so he naturally chose to use the same LabVIEW API to access I/O on BBB and RPi2.  The underlying implementation on the BBB/RPi2 is fundamentally different than the normal LINX toolkit.  Details on the architecture is available here.  The source code for the library is available here.

Issues encountered
I worked on making the LabVIEW run-time engine work on the BBB/RPi2.  The LV run-time had previously been ported to the ARMv7a CPU architecture and the Linux operating system in order to enable the latest generation of NI's CompactRIO industrial controllers.  This made things way easier but there were still some issues that had to be overcome:
  1. The run-time was already built around the fact that it was running on the an armv7a architecture.  This is fine for the CPU on the BeagleBone Black and the Raspberry Pi 2 and 3.  But the Raspberry Pi 0 and 1 use an older CPU that only supports the armv6 instruction set, so for this reason we decided not to support the older Raspberry Pis.
  2. The LV run-time usually runs on Linux in NI's own embedded Linux distribution, but for the BBB and RPi we wanted to make LabVIEW run on the recommended Linux distro for each of these targets which happens to be debian based.
  3. The ARM Linux versions of the LabVIEW run-time and the rest of the NI software stack are compiled with the softfp gcc flag, while most ARM Linux distros use the hardfp flag.  Binaries built with one flag are incompatible with binaries built with the other.  These means that the LabVIEW run-time cannot use the hardfp libc that is present on Raspbian.  That's a problem.
Solutions found
The first issue is kind of a limitation of the CPU in the Raspberry 1 and since most people are using the
newer Raspberry Pi 2 or 3, we decided that the easiest way to resolve the issue was to not support the RPi 1.  I know it kind of sucks for people that want to use the RPi1 they have lying in a drawer somewhere but considering how cheap RPi's are in general, it doesn't seem like such a big deal.

To solve the rest of the issues, I decided to use a Linux chroot.  At it's core, a chroot, or root jail, runs a process with a different root directory.  That's really all there is to it, but the implications are pretty far reaching.  When a process runs it loads its libraries from the /lib directory among others, so if we provide a softfp set of libraries in a different directory and chroot the LabVIEW process to that directory then we can solve issue 3.  And if, also in that same chroot directory, we provide a simple Linux distro that is custom-tailored to LabVIEW, then we can solve issue 2.

Building chroots in Yocto
To make this little chroot Linux distro, I used the Yocto project, which I was already familiar with because I use it at work on a daily basis.  I created a Yocto layer that has everything needed to create chroot.  The image recipe includes the LabVIEW run-time engine and the VISA and LINX I/O libraries.

Installing the chroot
With the chroot image created, I needed some way to install it on a target.  Since both the BBB and RPi use Debian-based Linux distros I create a deb package installer.  The install includes the chroot image created using Yocto, a systemd unit file to start the chroot and LabVIEW run-time at boot, a dependency to the schroot utility, and a small daemon that I'll discuss below.

Emulating the NI System Web Server
On traditional NI Linux RT targets, there is a system web server which provides various system configuration services like changing the network settings.  We don't support most of these system configuration services, but we do need to support restarting the LabVIEW run-time.  This is needed because when deploying a LabVIEW startup app to the target, the run-time needs to be restarted.

Since we only needed this service, rather than skimming though the significant codebase of the System Web Server, I instead took the tact of reverse-engineering the reboot web service using Wireshark.  Basically, I ran a Wireshark capture while remotely restarting a traditional LabVIEW Real-Time target.  This worked far better than I would have guessed, and soon I had a small script which implements a small subset of the NI System Web Server's functionality.  I created another systemd unit file to start the script at boot time and put it all into the debian installer.

On important note is that the NI System Web Server does lots of work to ensure that all of it's operations are handled securely, but for my quick-and-dirty python script I did not implement any of these security features.  The LabVIEW run-time is also run as the root user so that it has access to the I/O resources that it needs.  On other LabVIEW Real-Time targets, and on Linux systems in general, daemons like the LabVIEW run-time do not run as root due to security concerns.

The implications of these choices is that anyone with access to your local network can restart the LabVIEW daemon remotely, and can run VIs on the BBB/RPi2.  This probably isn't a big deal if your network is private and has a firewall between it and the rest of the Internet, but it's still something to be aware of.

Thursday, June 09, 2016

Introducing LabVIEW support for Raspberry Pi 2 and BeagleBone Black

For the last 6 months, a friend and I have been working on a really cool project, and now I can finally talk about it.

We've always wanted a way to use LabVIEW to program the amazing Linux-based maker devices like the Raspberry Pi and BeagleBone Black.  It seems like a natural fit for programmers that are new to distributed programming, embedded devices, and Linux.  LabVIEW has been an excellent way to write, debug, and deploy embedded applications over a network with the LabVIEW Real-Time module.

So we set out to port the LabVIEW Real-Time module to the BBB and RPi2.  Mainly this consisted of getting the LabVIEW run-time engine running on the BBB/RPi2 and writing some kind of I/O library to make it easy to do things like reading and writing digital lines, reading analog inputs, and communicating on I2C and SPI buses.

In the end, we got it all working and released it to the public, and it's actually affordable as well ($50 + cost of hardware).  All you need is a copy of LabVIEW 2014, the (free) LINX toolkit, and a BeagleBone Black or Raspberry Pi 2 or 3. See this link for more info.

We also spent some time putting together some respectable tutorials to help people get started.

What will you do with LabVIEW on a BBB or RPi?  I'm looking at automating the beer making process, and I've got some friends that want to use it with rockets and robots and other interesting things...

Sunday, March 20, 2016

Creating a customized image for BeagleBone Black or Raspberry Pi

Recently I wanted to create a customized image for a Raspberry Pi.  Basically, I just wanted to download a stock Raspbian image, install some software, change a few configuration settings, and then put it back together just as I'd gotten from the original image.

This is (or should be) pretty simple but I had trouble finding concise instructions for doing it.  What I found fell into one of two categories: 1) instructions for backing up an image, or 2) really complex instructions for generating an image from scratch.

At first glance the backup instructions (like these) seemed perfect.  You run the equivalent of Linux's dd command and end up with an image file that can be flashed to an SD card on Windows, Linux, or Mac.  Perfect, right?  Maybe not.  Here's a scenario I ran into:  I downloaded an image that would fit on a 4GB SD card, I flashed it on an 8GB card because that's what I had lying around, made my modifications, and created a backup image.  The problem was the image is an image of an 8GB card, so it will no longer fit on a 4GB SD card even though the amount of actual data on the card should allow it to live on a 4GB card.

So here is a process that gives us the ease of the backup process, but with the power to resize things back to the original image size:
  1. Download the latest official image for Raspberry Pi or BeagleBone Black.
  2. Extract the image, flash it, and boot it.
  3. Make whatever changes you want to the image (install software, change configurations, etc.).  Keep all other settings to the defaults, like the hostname, users, and passwords.
  4. Shutdown the target, extract the SD card, and backup the image using one of the methods here.
  5. This will backup the entire SD card, and will likely create an image that will be much too large.  You can shave off the extra unallocated space (basically restore it back to the same size as the stock image download from Step 1), using the steps in the "Shaving the Image" section of this document.
  6. Zip up the finished img file.

Thursday, March 17, 2016

Controlling flow through a wort chiller, part 2

Continuing my series of posts with boring-sounding names, I've got more results from my wort chiller pump.  Last time I was trying to control the flow through the wort chiller such that I can ensure that hot wort gets cooled to a reasonable temperature by the time it leaves the chiller.

To that end, I made a series of flow restrictors, which are just some smaller diameter tubes I could insert in the tube between the chiller and the fermenter vessel.

Flow Restrictors
I made the restrictors out of some wooden dowel rods I had lying around.  Yes, I know that wood is one of the worst materials I could have used for this purpose since it's porous, and therefore could leak air and water and be a wonderful home to unwanted bacteria.  I started with wood because I already had it on hand and I'm a woodworker so I'm better equipped to machine something out of wood. So if the experiment works I'll definitely be re-making the restrictor tube out of metal or food-safe plastic.

To start making the restrictors I found a dowel rod that would fit snugly in the 1/4" ID hose I was using, which I think ended being a 3/8" dowel.  I cut a bunch of 2 inch lengths of dowel and then picked 3 diameters I wanted to try first: 1/8", 3/32", and 1/16".  I clamped each rod in a wooden clamp, checked that it was perpendicular, and used my drill press to drill straight through the center of the dowel.  After that I checked each rod into the drill press and used a file to taper the ends so it would insert into the tubing more easily.  They ended up coming out pretty well, but not perfectly centered which should be fine for this experiment.

Measuring Initial Air Evacuation
Before I got to testing my new flow restrictors I wanted to investigate the initial start of the pumping process.  I suspected that it would take some amount of time to evacuate most of the air from the system before the liquid would start flowing.  To test this I used my usual volume of 16oz. of water to pump, but before the container was empty I poured in another 16 oz. of liquid.  By timing both a 16 oz. and 32 oz. sample, and subtracting the difference between them I should be able to get an idea of the amount of time required to evacuate the air.

For this test I ran the pump full speed at 5 volts.  Here are my results:
16 oz. water0m 41s
32 oz. water1m 06s
delta0m 25s
air evac time0m 16s

Breaking the results down a bit, this means that the time to transfer 16 oz. of water is really about 25 seconds and it takes 16 seconds to remove most of the air from the inside of the pump apparatus.  For the following tests I won't be adjusting for this initialization period, but it's something good to keep in mind.

Full-speed Flow Measurement
For the next round of tests, I kept the pump on full speed at 5 volts for the full duration of time it took to transfer 16 oz. of water.  As you can see in the picture below, I inserted the flow restrictor in the hose that connects the output of the graham condenser to the input of the fermenting vessel.

Here are my results:
restrictor size16 oz. transfer time
none0m 41s
1/8"0m 47s
3/32"1m 02s
1/16"3m 20s

It seems that the restrictors are working though their effect is definitely non-linear.

Modulating the Pump Motor
Next I wanted to try to introduce another variable into the equation, which is to vary the on-time of the pump.  In other circumstances I would use pulse-width modulation to allow a microcontrollers (like an Arduino) to control the motor, but for now I don't want to mess with setting up the motor drive circuitry.  So I'm going to do "human powered" pulse width modulation and just turn the pump motor on and off in terms of seconds.

Here are the patterns I came up with:
pattern numinit periodrepeating pattern
10s10s on, 10s off
220s10s off, 10s on
30s20s on, 20s off
410s10s off, 5s on
510s10s off, 3s on
610s10s off, 2s on

Each pattern has an (optional) init period where the pump is on, with the goal of initially evacuating the air from the system.  After the init period, each pattern has a repeating pattern with the goal of replicating the duty cycle and period based control used in pulse width modulation.

I ran these patterns using the 3/32" restrictor since this restrictor seemed to give the best balance of hole size vs. flow restriction.  I want to keep the hole size as large as possible because I'm concerned that if the hole is too small it will get clogged when I run actual wort through it.

Here are my results with the 3/32" restrictor:
pattern num16 oz. transfer time
11m 14s
21m 11s
31m 12s
41m 21s
51m 33s
62m 46s

So it seems that my simplistic pump motor modulation is working, at least enough to proceed.  I could have tried a pattern with an even shorter on time than pattern 6, but a 2s on time was about the shortest amount of time that I could consistently maintain over over the course of several minutes.

It's worth noting that by the end of my test runs the 3/32" restrictor was allowing a small amount of outside air to be pulled inside the tubing.  I think this may change the results slightly, but I don't think it would have changed things enough to alter my conclusion that the strategy seems viable.

Conclusions and Future Work
The results from using a restrictor while modulating the vacuum pump seems to show enough promise to proceed.  If you multiply out the time to transfer 16 oz. of water with around a 20% duty cycle, it would probably take around 24 minutes to transfer a gallon of wort through the chiller which seems like it should be sufficient to chill down to room temperature.

My next steps are to get my test rig ready to pump some near-boiling water though it, make a 3/32" restrictor out of something more durable than wood, and add some automation to control the vacuum pump motor.

Thursday, January 21, 2016

Controlling flow through a wort chiller, part 1

Now it's time to start putting together my last two experiments in order to control how quickly the wort flows through the chiller.  This will hopefully allow me to control how quickly and efficiently the wort is chilled.

I've added a stainless steel racking cane as an input tube to the condenser tube.  The condenser tube is now better supported with a ring clamp that allows me to keep tube properly supported at an adjustable angle. The tube that leads into the glass jug is just the right diameter to fit snugly in the output of the condenser tube.

As part of this I also want to try and slow down the flow of water through the condenser tube.  I took a simple approach of using a pinch clamp to see how much that restricts the flow.  I then pulled 16 ounces of water and timed how long it took on a stop watch.

table of data
clamp gap(cm) transfer time(s)
open 0:38
0.5 0:38
0.4 0:38
0.35 0:41

Based on the numbers I collected, it seems that the pinch clamp is effectively binary, all off or all on.

Since the pinch clamp didn't work very well, I'm going to try inlining a smaller tube to see if that restricts the flow better.