I am considering the following three options. Only option 3 has been fleshed out in substantial detail, since it will likely break more new ground than the other two. However, all three have merits that make them worth exploring.
Option 1
Choose RepRap or Fab@Home as a starting point. Build one of those machines, identify and implement incremental improvements.
Option 2
Build something that amounts to a pick&place Lego assembly machine. Make the initial machine out of Lego parts. When necessary, invent new Lego parts in order to completely achieve this goal.
Option 3
Self-assembling autonomous bricks with legs.
Project
Description
Processes
used by machine
Capabilities
Comparison
with similar systems
System
Components
Development
required
Tasks
Cost
Speed
Consumables
Design
of Individual Blocks
The ABLE (Autonomous Bricks with Legs, Eh?) project consists of a single design for a brick which forms an atomic unit in larger constructions. It is assumed that an external agent will build a structure using these bricks, which sets the initial “seed” structure. The bricks as individuals are then capable of movement and negotiation, recruiting new bricks to build copies of the structure. Given an infinite supply of bricks, they will build an infinite number of copies, with the structures in each generation capable of making more, thus performing distributed assembly to the maximum extent possible.
The individual blocks require a fairly rich set of logic, communication, and mobility. A description of the operating modes of the blocks, along with their communication protocols, negotiation algorithms, and movement (mobility and attachment) mechanisms are described below under the Design of Individual Blocks.
Each block has three possible operating modes:
Manual assembly
Structure identification
Self-assembly
Each block is built identically. The only differences between blocks are their stored state information.
The blocks are able to autonomously move in any direction and rotate.
Blocks are able to communicate with other blocks in direct physical contact.
An external agent (a human) will put a finite set of blocks into “manual assembly mode”, and make connections between blocks in order to create an object built from multiple blocks.
The external agent instructs one (or more) of the blocks in the construction that it should go into “structure identification” mode. This causes every connected block in the structure to communicate with its neighbors, obtaining a global understanding of the configuration of the entire structure. Each block in the structure saves information about the global configuration. The algorithm for learning and sharing the global configuration is described later.
As soon as a block learns the global structure information, it will detach itself from its neighbors, and place itself in self-assembly mode.
Blocks in self-assembly mode wander freely. When they bump into other blocks, they negotiate and decide whether to form an attachment (negotiation algorithm described below). Eventually a new structure is formed, matching the original seed structure. Instead of just a single new copy, we have the potential for N copies to be made at each generation from an original structure composed of N blocks. In practice, the number of duplicates will be somewhere between 1 and N, with some variation resulting both from which blocks happen to come in contact with each other, and the details of the attachment negotiation algorithm.
Learning and sharing information describing the entire contiguous structure is fairly straightforward, complicated only by the fact that no individual block is in charge. The information must be constructed as a network of peers, with each member trying to learn the whole structure at the same time.
The problem becomes easy if we allow ourselves to assume that each block is guaranteed to have a unique ID.
When two blocks in self-assembly mode come in contact with each other, they will negotiate their identities, and whether or not to make an attachment. Each block that is in self assembly mode has the following internal state:
It knows the shape of the entire structure which it is trying to build
It knows which element of the final structure it wants to be.
If any blocks are already connected to it, it knows the quantity, position, and identity of all the connected blocks
When two blocks come in contact, they may be trying to build the same structure, or they may be trying to build two completely unrelated structures. If the blocks negotiating the connection already have some blocks attached to themselves, then the block that has gathered the most attachments (through its entire contiguous structure of interconnected blocks) will convince the other block to change its identity, to relinquish all its existing connections (if necessary), and join the first block to build the structure.
Each block is capable of traveling on its own (moving forward, backward, and rotating).
Blocks which are connected to each other coordinate such that they all travel in the same direction.
There are several approaches we can take for coordinating the movements of connected blocks. Perhaps the simplest method is to elect a leader, but there are other interesting things we can do. Examples include having a simple set of rules that would cause all the blocks to make similar decisions, and then conflicts could be resolved locally.