Friday, May 12, 2017

Donut Counting with LabVIEW and BeagleBone Black

While creating tutorials for the LabVIEW Web Services feature of LINX, I needed a simple real-world example application.  I think I came up with one of the dumbest possible projects to serve that purpose.

Where I work, there is a long-standing tradition to bring in donuts when making some announcement.  So when we released LabVIEW support for Raspberry Pi and BeagleBone Black devices, I wanted to combine donuts with one of those devices in some way.  I also wanted to make the project electrically simple and easy from a software perspective as well.

What I came up with is a BeagleBone Black serving up a web page that shows how many donuts are remaining in a donut box.

The circuit is super simple, it's just a photo-resistor hooked up to one of the analog inputs of the BBB.  The LabVIEW application detects that the box lid is open or closed based on reading the resistance of the sensor, and then implements a simple state machine that decrements a counter when the box lid is opened and then closed (I assume that each person is only taking one donut).  The LabVIEW app then serves up a static web page that displays the current donut count that accesses the current counter value via a LV web service.  There is also a LV web service method that allows you to set the current count value so you can input the initial number of donuts in the box.

It's definitely a silly toy application, but I think it serves as a simple example of LabVIEW Web Services that interfaces to real-world I/O.  All of the source code is available on github.

Sunday, April 02, 2017

LabVIEW Web Services on BBB/RPi

It's been some time since it released to the public but I'd like to talk through some of the technical details that make LabVIEW Web Services (LVWS) work on the Raspberry Pi and BeagleBone Black.

LabVIEW has had support for Web Services for many years, The basic idea is that a VI can be automatically turned into a REST interface and served up via an HTTP server built-into the LabVIEW run-time engine.  This allows an easy path to creating a web-enabled LabVIEW application.

Although we didn't have LabVIEW Web Services enabled in the intial release of the LabVIEW support for BBB and RPi, we knew how important it would be to have a way to create web interfaces for their embedded LabVIEW applications, which are generally headless (no local user interface).  So as soon as we released LINX 3.0, we immediately started work on getting LVWS working, and after a few months of work we released the support to the community as an update to LINX.  Along with that we even created a tutorial to introduce this new capability to the community.

Removing NIAuth
The NIAuth system is a PAM module that allows for creating users and setting permssions through the NI Measurement and Automation Explorer (MAX).  MAX isn't supported on BBB/RPi because we have a more focused Target Configuration tool which is more appropriate for these devices.  We also are less focused on users and permissions for these targets so it made sense to simply remove the NIAuth tie-ins in LVWS for these devices.  This proved to be more work than we thought because there were a number of assumptions in the code that depend on NIAuth being present.  In the end, this was the majority of the work required to get LVWS up and running.

HTTPS Support
One of the features of LVWS is the ability to enable HTTPS to allow for secure web service access.  Unfortunately, the HTTPS support didn't work "for free", and so we made the decision to release LVWS support without working HTTPS support.  Sorry, we tried.  We'll probably get back around to this at some point but no promised ETA.

In the meantime, one of my colleagues came up with a clever way to "wrap" HTTPS support on LVWS in order to get LabVIEW to work with the Amazon Alexa service.  The tutorial is a great one to read in general, but you can re-use the httpsHelper Node.js script to wrap your own custom LV web service.

A UI for your BBB/RPi
Usually the next thing users ask when learning about LabVIEW Web Services is how to create a UI that access the LVWS.  You can access the web service with a web browser (for HTTP GET methods) or the curl utility (for HTTP POST methods).  This is very useful for debugging, but is probably not sufficient for a real user interface.  One method is to create a static web page is using HTML and Javascript that calls your LVWS to read or write data, but many users aren't too interested in learning a text-based programming language and HTML when they're already using a graphical programming language in LabVIEW.  This tutorial uses HTML and Javascript to create a web-based UI.

Data Dashboard
Data Dashboard is a free mobile app available for iOS and Android (tablets, not phones) that gives you a pretty nice UI design tool.  Data Dashboard can interface directly with LVWS to allow creating a mobile-friendly a UI.  As a side benefit of the work we had already done to enable LVWS, the Data Dashboard app worked with Raspberry Pi and BeagleBone Black targets.  This is a really nice option for users that want to avoid doing any text-based HTML or Javascript coding.  We created a tutorial on how to use LVWS with Data Dashboard.

Calling REST interface with the LV HTTP VIs
Another way to create a web-based UI for a LabVIEW app came from the Makerhub Forums.  The basic idea is that you create an LVWS interface for your LabVIEW app running on a RPi or BBB, and then create a client LabVIEW app on a desktop machine that interfaces to the target's LVWS interface using the LabVIEW HTTP VIs.  The upside to this strategy is that you can once again avoid coding HTML or Javascript, but the downside is that you must have LabVIEW running on the client device, which precludes having this UI on devices like smartphones.

Monday, November 07, 2016

Building a workbench without a workbench

I've been learning to use hand tools and I've quickly realized that a good workbench is essential.  With power tools, like a table saw or drill press, the tool itself often supports the wood.  But with hand tools you must have something to support the wood while you bring the tool to the wood.

So I've started to build a workbench (more on that later).  The first problem I've run into is that I'm using hand tools to build a workbench, so...  Chicken or the egg...

Here's some tricks that I've come up with to hold boards while I work on them.

The simplest trick is to use a table against a wall stud.  The board butts up to the stud for face planing.  The board can be offset from the wall stud with scrap wood so that you can plane up to the end of the board without running the plane into the stud.  If the board is long, the far end can be supported with a sawhorse.

If the board is the same thickness or thinner than the scrap wood blocks then I've found it handy to put a small wedge under the board to raise it above the level of the scrap blocks.

The last trick is useful for edge planing a board.  Turn the board on edge and butt it against the scrap wood blocks and wall stud, as before.  Then to secure it in place I put more scrap wood blocks on either side of the board and clamp them in place to keep the board from tipping in either direction.

These tricks work, but they're not ideal, and it's really making me look forward to when the bench will be done and ready to use.

Sunday, November 06, 2016

Things I've learned about the lowly block plane

As part of my workbench build, I've been planing some end grain after making crosscuts on boards. The usual tool for this job is the often overlooked block plane. I've found that it's pretty hard to plane edge grain well!

The problem is when planing end grain you are cutting across all the wood fibers, instead of splitting off a few long wood fibers as you do when planing with the grain.

Here's that I've figured out so far:
  • Make sure the plane blade is as sharp as possible.  This is always true, but with other planes you can get by with a less than razor-sharp blade
  • Set the depth of the plane blade to take a very shallow cut, otherwise the plane will be hard to push and may chatter.
  • It helps to make a skew cut on the end grain (turn the plane at a 45-ish degree angle to the board)
  • Soak the end grain with a bit of alcohol to soften the wood fibers
  • Make sure you're putting enough downforce on the front of the plane. If you have too much force on the back of the plane then it may cause the blade to chatter
  • If the plane has an adjustable mouth, adjusting it to make the opening smaller helps with making shallow cuts
  • If you have one available, use a low angle plane, as the lower angle of the blade makes it significantly easier to cut end grain.
A fine tool, but maybe not for planing end grain

I started off with my vintage block plane, which is basically a Sargent 306.  It's a good plane but adjusting it to cut end grain well was tricky.  There were several issues with that plane:
  • The depth adjuster had alot of backlash, meaning it was hard to get a really precise depth adjustment
  • Locking the blade with the lever cap tended to change the depth and lateral adjustment of the plane a little, which usually meant it took several tries to get it properly adjusted
  • The plane is not a low angle plane

A New Plane
Just when I was getting frustrated, I lucked out and my Mom found a vintage Stanley no. 60-1/2 low angle block plane at an antique store (Thanks Mom!).  It needed a little work to tune it up, but it was in good shape.

When I tune up planes I usually clean the grime and rust off, but leave some of the patina that makes it look old.  This is less work and in my opinion looks better anyway.  Some people prefer to make the plane look like the day it rolled out of the factory, but that's more than is required to make the plane function like it's brand new.

Here's a few before and after pictures:
Top: before, Bottom: after.  Not much difference visibly except there was lots of paint and grime in the knurling and threads of the depth adjuster.  I cleaned that out with a dental pick.

Again not much visible difference except that the blade was previously coated with lacquer or paint to protect it from rust, I guess.

The blade was sharpened with quite a bit of skew. I straightened it out on the grinder.

After flattening and polishing the back of the blade.  There is a bit of pitting, but nothing catastrophic.

The plane sole was in pretty good condition.  I made sure it was flat and shined it up a bit.

The first cut: works like a champ!

You never quite know how good a plane is going to be until you're done tuning it up, but this one turned out really well. Here's the payoff:

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.