From Hackerspace To Your Garage: Downloading DIY Hardware Over the Web
What does open source software have in common with manufactured parts? Both involve a growing movement of “do it yourself” (DIY) packaging and distribution that follows the open source model of the free Linux operating system (OS). In other words, as with free software, you will likely soon be able to download hardware from the web in the form of free packages of coded instructions to make… well, just about anything — from a Lego block to the jet engine of an F-16.
The impetus behind downloading DIY hardware from the web is to leverage hackerspaces (those collaborative dens of real world hacking), fab labs (fabrication laboratories), and other groups around the world to shift the burden away from “makers” (manufacturers) to a core group of package maintainers who verify hardware designs and make it easy for makers to do what they love best — making things.
And this involves making real stuff, not just code. “Recently a guy reinvented the fabric of industrial society in his garage,” writes Kevin Kelly of the late Dave Gingery, a midnight machinist in Springfield, Missouri. Gingery enjoyed the challenge of “making something from nothing,” and had a knack for piecing together a complete machine shop from alley scraps. “He made rough tools that made better tools, which then made tools good enough to make real stuff,” Kelly continues. The spirit of Gingery lives on in the hearts of makers today.
Gingery is an interesting example of one side of DIY manufacturing equation — the fabrication of “real stuff” from machine tools such as lathes, shapers, planers, and hexapods. One example of the other side of this equation is represented by something known as the Enhanced Machine Controller or EMC. The EMC is a powerful and free software system for controlling machine tools that accepts programs in G-code (the RS-274 standard machine tool programming language). The computer code causes the machine tools to move. And moving tools make stuff.
Let’s take the simple example of a Lego block. In addition to the dimensions, the object’s specification includes the spacing of the stud centers, the stud diameter, and the thickness of the brick walls. Here’s an example of the encoded description of a single Lego block:
author: ‘ben lipkowitz’
name: technic pin
point: [0.0, 0.0, 0.0]
x_vec: [1.0, 0.0, 0.0]
y_vec: [0.0, 1.0, 0.0]
point: [0.0, 0.0, -16.0]
x_vec: [1.0, 0.0, 0.0]
y_vec: [0.0, -1.0, 0.0]
The user is freed to make stuff, rather than chasing down dependencies. Slowly but surely, computer algorithms are taking over these tasks.
This hardware specification applies the lessons learned from dependency resolution in open source software development (making sure one piece of software works with another) to manufacturing and the art of building things. The goal is to download the Lego block — or any other part or assembly — over the web. This means providing instructions to a home PC to fabricate the block in your personal fab lab, or even your garage. Today people read and carry out these instructions, but computers and machines are starting to pick up the load.
The dependency tree for a Lego block includes options like plastic injection molding and 3D printing. This “metadata” information ultimately provides the instructions to build a DIY object. These instructions tend to be much more precise, machine readable, and user friendly than an “Instructable” (a set of instructions provided at the DIY website instructables.com).
Reengineering the delivery of physical products over the internet is also reengineering the social fabric to manage DIY manufacturing. The Lego block example comes from the Social Engineering-Knowledge Database (SKDB) project that provides the means for specifying dependencies and applying standards that can be shared by open source DIY makers. You don’t need to reinvent the wheel every time you begin a new project. Someone may have already done most or all of the work for whatever you are trying to do, and then released the plans on the internet. And there are many common tools and parts involved in making things. The SKDB project directly tackles the challenge of packaging and distributing these plans. Here’s a two-part video of a recent presentation on the SKDB project:
The SKDB project simplifies the process of searching for free hardware designs, comparing part compatibility, building lists of materials and components, and determining where to get them by organizing them into packages. For example, in the world of the open source and free Debian distribution of the Linux OS, packages involve the apt-get command, a powerful tool that installs new software packages and upgrades existing software packages. Debian comes with over 25,000 free packages — precompiled software bundled up in a nice format for easy downloading and installation.
The open source Debian packaging and distribution model is built on the Debian social contract. This contract, familiar to open source developers, is a set of commitments that hackers — who freely contribute their time to building the OS — agree to abide by in order to use the software. Here are the basic principles:
- Debian will remain 100% free.
- We will give back to the free software community.
- We will not hide problems.
- Our priorities are our users and free software.
- Works that do not meet our free software standards are not part of the Debian system.
Software package managers are critical to the success of Debian and Ubuntu (another free OS that proudly proclaims “you can download, use and share Ubuntu with your friends, family, school or business for absolutely nothing”). They are essential to DIY open hardware as well. Rather than spending hours trying to track down free copies of the dependencies, or searching the web for days for the right versions, package managers do the work.
And why should a hacker stop with just version control? Why not use hardware packages to make a lab or to make tools for an experiment? Instead of painfully picking through websites like instructables.com, thingiverse.com, or hardcopy magazines, package managers do the gritty work — generate the instructions or order parts over the web — and the user is freed to make stuff, rather than chasing down dependencies. Slowly but surely, computer algorithms are taking over these tasks.
The SKDB project is like apt-get, but for real stuff. In the SKDB project, hardware specifications are organized into packages. Packages are a standard and consistent way for programs to find data. They can contain the following:
- CAD files,
- CAM parameters,
- computer-readable descriptions of product specifications,
- product-specific code,
- instructions for assembly and construction, and
- a bill of materials.
For each part in a package, there are a number of interface definitions that describe how the part can connect with other parts, even parts from other packages. Each package also lists dependencies which have to be bought or built in order to successfully carry out a project. For example, a drill press is required to make holes with a certain level of accuracy. The SKDB project downloads all of the dependencies automatically and compares them to your existing inventory, and generates instructions for your computer numerical controlled (CNC) machinery, if you have any. A CNC machine is a machine tool that uses programs to automatically execute a series of machining operations.
With OpenCASCADE, an open source CAD geometry kernel, parts can be visualized and combined in real time to show new assemblies and constructions. 3D pictures contain information that can be used to automatically generate instructions for assembling the parts and projects into human-readable and robot-readable G-code instructions. A wiki-like frontend to the SKDB project is in the process of being integrated with the free git distributed revision control system so that hackers working on a project can publish and share their modifications with the rest of the world. These tools are vital to the future success of DIY collaborative and free manufacturing. Without a solid base for sharing and building upon each other’s work, the movement will flounder.
Kevin Kelly, who saw the potential to re-invent the fabric of industrial society in Dave Gingery’s home fab lab, has also written some other thoughtful pieces on civilization as a sort of organism or creature or monster. “I’ve been thinking of civilization (the technium) as a life form, as a self-replicating structure,” writes Kelly. “I began to wonder what is the smallest seed into which you could reduce the ‘genes’ of civilization, and have it unfold again, sufficient that it could also make another seed again. That is, what is the smallest seed of the technium that is viable? It must be a seed able to grow to reproduction age and express itself as a full-fledge civilization and have offspring itself — another replicating seed.”
Kelly saw this “seed” as a library full of knowledge and perhaps tools. It was this concept of a seed library of knowledge in the form of the SKDB project — paired with Gingery machine enthusiasts pouring molten metal into the shape of metal-cutting lathes — that inspired the vision of controlling and maintaining a repository for downloading machine-readable instructions that can be converted into stuff.
Translating bits and bytes on the web into something physical (atoms) requires a mechanism. In the case of DNA, this mechanism is a ribosome which assembles proteins from the coded data on a molecule of messenger RNA (mRNA). The SKDB project can be just such a mechanism for sharing hardware over the internet — ultimately translating the contents of packages into things. This can include DIY biology lab equipment, like pipettes, test tubes, racks, refrigerators, thermocyclers, cameras, spectrophotometers, and autoclaves to work with the reusable genetic building blocks of synthetic biology.
How soon will the designs of hackerspace be made available over the internet to the machine shop in your garage? Perhaps much sooner than you would guess. Machine-readable instructions such as G-code exist today, but they aren’t always human readable. Debian has an estimated $13 billion of volunteer hacker time invested in it. While the SKDB project is still in its infancy, technical demonstrations exist today and the movement is growing. “Making something from nothing” may be as close as the next hacker.
Interested in hacking open source hardware packages? Bryan Bishop and Ben Lipkowitz are forming a transhuman technology co-op powered by open source hardware. On the off-chance that you’re not involved, you should be — contact the community today at: email@example.com