localization techniques for synthetic realityclaytronics/software/localization-stuff/...localization...
TRANSCRIPT
Localization Techniques for Synthetic Reality
by
Greg Reshko
Submitted to the School of Computer Sciencein partial fulfillment of the requirements for the degree of
Master of Science in Computer Science
at the
CARNEGIE MELLON UNIVERSITY
August 2004
c© Carnegie Mellon University 2004. All rights reserved.
Committee:
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Seth C. Goldstein, Chair
Professor of Computer Science, Carnegie Mellon University
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .Todd C. Mowry
Director, Intel Research PittsburghProfessor of Computer Science, Carnegie Mellon University
Localization Techniques for Synthetic Reality
by
Greg Reshko
Submitted to the School of Computer Scienceon August 10, 2004, in partial fulfillment of the
requirements for the degree ofMaster of Science in Computer Science
Abstract
Synthetic Reality is the next generation form of capture and synthesis of environments.Similar to how audio and video technologies are capable of reproducing sound and images,this project will synthesize any environment by constructing a physical artifact using a formof programmable matter called Claytronics. One of the challenges in Synthetic Reality isthe localization of myriads of nodes that compose the system. In this thesis, we address andexplore this localization problem. We design several algorithms to establish position as wellas orientation of the nodes. The scalability of the system is addressed by developing thealgorithms in a fully distributed fashion. Correctness and performance of these techniquesis demonstrated by implementing the algorithms on a simulator. We present the results ofsuch localization algorithms as well as ideas and motivation behind them.
Thesis Supervisor: Seth C. GoldsteinTitle: Professor of Computer Science
2
Acknowledgments
I would like to thank my advisor Seth Goldstein and members of the Synthetic Reality
project group at Carnegie Mellon for making this thesis possible. I would also like to express
my gratitude to Matt Mason and members of the Manipulation Lab for previous years of
wonderful research experience and introducing me to research in general. Many thanks also
go to the undergraduate dean and advisor Mark Stehlik for helping me with everything
during my four years at Carnegie Mellon. Mark is the best advisor I have ever met and his
dedication to his students is truly admirable. Last, but definitely not least, I would like to
thank my good friends for their moral support during the writing of this thesis.
3
Contents
1 Introduction 8
1.1 Synthetic Reality . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.2 Vision and Goals . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.3 Claytronics . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.4 Contributions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
2 Localization 14
2.1 Existing Systems . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
2.2 Architecture and Design . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3 Hardware . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.3.1 Wired vs. Wireless . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.3.2 Antennas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
2.4 Existing Algorithms . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
2.5 Simulation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
2.5.1 Physically Based Model . . . . . . . . . . . . . . . . . . . . . . . . . 22
2.5.2 Collision Detection and Response . . . . . . . . . . . . . . . . . . . . 24
2.5.3 Implementation Details . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2.5.4 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
3 Localization Algorithms 29
3.1 Establishing Position . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.2 Actions and States . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
3.3 Virtual Anchor Generation . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
4
3.3.1 Single Anchor . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.3.2 Multiple Anchors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.4 Uniform Lattice Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4.1 Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
3.4.2 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 38
3.4.3 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
3.5 Distributed Localization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3.5.1 Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
3.5.2 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
3.5.3 Analysis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3.6 Sweeping Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.6.1 Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3.6.2 Results . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
3.7 Multi-Cluster Localization . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.7.1 RF Multi-Node Beacons . . . . . . . . . . . . . . . . . . . . . . . . . 52
3.7.2 Messenger Clusters . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.7.3 Physical Bridge . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
3.7.4 Rapidly Expanding Random Trees . . . . . . . . . . . . . . . . . . . 54
3.8 3D Localization . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3.8.1 Single Seed . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.8.2 Distributed Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . 56
3.9 3D Sweeping . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 59
3.10 Grain Boundaries . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.10.1 Phase I . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
3.10.2 Phase II . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
3.11 Summary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
4 Conclusion and Future Work 63
5
List of Figures
1-1 Communication mediums: audio, video, and pario. . . . . . . . . . . . . . . 10
1-2 (a) Planar catom prototype. Components of the catom: (b) PIC processor
and power converter, (c) magnets board, (d) RF transmitter and receiver, and
(e) LCD screen. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1-3 Catom rotation. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2-1 Signal strength of the monopole antenna. . . . . . . . . . . . . . . . . . . . . 19
2-2 Force field of (a) bar magnet and (b) point charges. . . . . . . . . . . . . . . 22
2-3 Magnet interaction between catoms. . . . . . . . . . . . . . . . . . . . . . . . 23
2-4 Collision detection and response using penalty forces. . . . . . . . . . . . . . 25
2-5 Frame-rate comparison of all-pairs and voxels. . . . . . . . . . . . . . . . . . 27
2-6 Simulation screen shot. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
3-1 Claytronics (a) square or (b) hexagonal lattice. . . . . . . . . . . . . . . . . . 29
3-2 Computing position of node D using nodes A, B, and C as reference. . . . . 30
3-3 Step-by-step lattice construction. . . . . . . . . . . . . . . . . . . . . . . . . 31
3-4 Actions and states. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3-5 Determining boundaries and center of the shape. . . . . . . . . . . . . . . . . 35
3-6 Automatic kernel generation from seeds. . . . . . . . . . . . . . . . . . . . . 36
3-7 Dipole invariant. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
3-8 Initial algorithm: (a) 3 seeds, (b) spread, and (c) final configuration. . . . . . 38
3-9 Improved bidirectional algorithm: (a) 3 seeds, (b) spread, and (c) final con-
figuration. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
3-10 Performance of several variations of the Lattice algorithm. . . . . . . . . . . 39
6
3-11 Coordinate frame mapping. . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
3-12 Steps taken by the scalable localization algorithm. . . . . . . . . . . . . . . . 44
3-13 Performance of (a) multi-frequency broadcast, (b) single-frequency broadcast,
and (c) optimal single-frequency braodcast. . . . . . . . . . . . . . . . . . . . 47
3-14 Performance of (a) the original algorithm, (b) single-frequency broadcast, and
(c) multi-frequency broadcast. . . . . . . . . . . . . . . . . . . . . . . . . . . 48
3-15 Sweeping algorithm idea. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
3-16 Sweeping algorithm screen shots. . . . . . . . . . . . . . . . . . . . . . . . . 51
3-17 RF multi-node beacon localization. . . . . . . . . . . . . . . . . . . . . . . . 53
3-18 Messenger clusters. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3-19 Physical bridge. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 53
3-20 Rapidly expanding random trees. . . . . . . . . . . . . . . . . . . . . . . . . 53
3-21 Localization in 3D. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 55
3-22 Steps taken by 3D localization algorithm with single seed. . . . . . . . . . . 57
3-23 Steps taken by 3D localization algorithm with multiple seeds. . . . . . . . . . 58
3-24 3D sweeping algorithm screen shots. . . . . . . . . . . . . . . . . . . . . . . . 59
3-25 Grain boundaries between clusters. . . . . . . . . . . . . . . . . . . . . . . . 60
3-26 Grain boundaries simulation. . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
7
Chapter 1
Introduction
Large-scale systems composed from thousands of tiny devices are becoming widely used in
a variety of applications. Sensor networks are a prominent example of such an application
that uses many small simple nodes to create a useful complex system.
One of the most important aspects of such systems is establishing location information
throughout the network of nodes. This localization task presents several difficulties – cor-
rectness, accuracy, and speed. Accuracy is usually chosen as the primary metric, since most
of the systems are directly used to compute the positions of objects, such as cell phones in a
network of cell phone towers. However, as the size of the system becomes significantly large,
the scalability of the approach becomes the crucial factor.
A variety of hardware and software approaches have been explored in the past to solve
the problem of establishing positions for myriads of nodes. The main difficulties in designing
such highly-scalable algorithms are that they must operate quickly, be robust, and present
an efficient way to propagate information between nodes.
Determining the orientation of individual nodes in addition to their position presents yet
another challenge. However, this is rarely explored since position information is usually more
important than orientation information. For example, when tracking down a stolen vehicle,
it is much more valuable to determine where the vehicle is currently located than which way
it is facing.
In this thesis, we design several localization algorithms that are capable of simultaneously
establishing the position and orientation for each node in a large system. The algorithms
8
are designed in a fully distributed fashion to avoid scalability problems. We address several
potential issues such as multi-cluster localization and misaligned boundaries. The perfor-
mance and correctness of these approaches are verified on a simulator. Although we explore
these approaches in the context of the Synthetic Reality framework, it is worth noting that
they are applicable to a variety of fields.
1.1 Synthetic Reality
Pario is a next generation form of replication and synthesis of an environment. Coming from
the Latin root ‘par’ meaning ‘to create’, and in contrast to video and audio, pario is a media
type that will allow users to create a dynamic physical artifact which will be a copy of the
matter that is being captured. The replica itself will be modeled via complex programmable
matter called Claytronics. Just as a photo-copier can produce a copy of a paper, Claytronics
will be able to produce a replica of the physical phenomenon being copied. Such Claytronic
objects can be used to create an entirely new replicated environment called Synthetic Reality.
Unlike virtual reality, Synthetic Reality will be a physically-constructed dynamic environ-
ment that will be a replica of the actual physical environment elsewhere. In the long term,
this will allow for the creation of high-fidelity three dimensional copies of objects that are
being replicated. As an extreme example, this technology will allow one to create a detailed
replica of a person thousands of miles away, similar to how phones and teleconferencing
allow us to replicate voice and images today. This idea is illustrated in Figure 1-1 – cell
phone is an example of an audio communication capable of retransmitting the ghosts voice
and video is capable of showing us the ghost on TV; Claytronics on the other hand, will be
capable of constructing a moving replica. The earlier versions, denoted by Claytronics 2D,
will be most likely two dimensional and will construct a crude approximation of the shape
– for example using cylinders or spheres as building blocks. However, the later and more
advanced systems, denoted by Claytronics 3D in the picture, will be able to construct an
artifact that will be nearly identical in appearance to the original shape.
9
Boo!Audio(Cell phone)
Video(TV)
Pario(Claytronics 2D)
Pario(Claytronics 3D)
Figure 1-1: Communication mediums: audio, video, and pario.
10
1.2 Vision and Goals
The applications and possibilities for pario are enormous. Just imagine a world where a
doctor can be synthesized directly right where the emergency occurred or a tiny football
game being played on your desk with tiny players running around the field. One can also
imagine objects that are being dynamically created around you as you need them. If you
need to eat dinner these tiny computers can form a table; and if you would like to watch TV
afterwards – they can form a couch for you to sit on.
While the ultimate intention is to have a working 3D version of Claytronics capable of all
of the above features, our short range goal is to bring to life a crude macro-scale prototype.
This prototype implementation will obviously lack many features, but it will be a good test
bed and will allow us to experiment with the functional hardware system.
1.3 Claytronics
Just like displays and speakers enabled video and audio replication, Claytronics will be the
technology behind constructing an instance of synthetic reality. Claytronics itself is a form
of programmable matter – a collection of nodes that can be reconfigured into any shape.
The nodes themselves are called catoms, standing for ‘Claytronic atoms’.
While some of the ideas and key concepts behind Claytronics might seem futuristic, the
overall design and the current prototype implementation are very much real. In order to
experiment, as well as to create the first functioning model of the system, we assembled a
macro-scale two-dimensional version of synthetic reality.
As shown in Figure 1-2, each catom is about 5cm in diameter, 5cm tall cylindrical stack
of circuit boards. The onboard processor is a low-cost and low-power PIC 16F877 CPU
[37]. The processor features 300 bytes of RAM and 8K bytes of ROM. Linx 900MHz RF
transmitter and receiver chips are used to enable communication between the catoms in the
system [34, 35]. In addition to that, each catom has a 6-line LCD display. Each component
is built on a separate circuit board and is connected to other components via a common
serial interface as shown in Figure 1-2. This modular design allows us to easily interchange
11
(a)
(b) (c)
(d) (e)
Figure 1-2: (a) Planar catom prototype. Components of the catom: (b) PIC processor andpower converter, (c) magnets board, (d) RF transmitter and receiver, and (e) LCD screen.
N S
N S
NS
N S
S N
S N
NS
NS
N S
N S
NS
N S
S N
N S
NS
SN
N S
N S
NS
N S
S N
S N
NS
NS
N S
N S
NS
N S
S N
N S
NS
SN
Figure 1-3: Catom rotation.
components as well as to perform hardware upgrades.
To create a certain shape, the system needs to have some means to reconfigure itself. In
the current implementation, we use electro-magnets to rearrange this macro-scale Claytronics
prototype. Electro-magnets provide a significant force needed to move the catoms and they
also only need to be powered when we need to invert the polarity of the magnet, which is
important in terms of power consumption constraints.
Thus in order to rearrange the system into some given shape, we can use the magnets to
rotate catoms around other catoms by using proper combinations of polarities as shown in
Figure 1-3.
One of the interesting aspects of the Claytronics is that each catom is completely self-
contained – all onboard electronics, magnets, and everything else is managed entirely by the
12
catom itself. However, what is also interesting is that each catom by itself is also completely
useless. Since catoms can only be moved using other catoms, the only way to rearrange
catoms into a shape is by using a collection of catom nodes.
This interesting requirement is the primary motivation for the first two steps of bringing
this prototype to life – communication and localization. We need to be able to establish
a reliable, efficient, and robust communication between all nodes, so that they can coordi-
nate their movement. We also need an ability to localize nodes with respect to their local
coordinate frame, primarily so that the system can have feedback on its current status.
1.4 Contributions
This thesis addresses one of the major challenges of Synthetic Reality – localization. We
present general architecture directions as well as design and evaluation of the current version
of localization subsystem. We also design and demonstrate several custom 2D and 3D
localization techniques.
We implement a powerful and versatile simulation framework to test the correctness of
implementation as well as performance of these algorithms. We determine the performance
and address the scalability concerns of these algorithms for the large-scale structures of
Claytronics. We also address many of the potential issues such as multi-cluster localization
and misaligned grain boundaries.
13
Chapter 2
Localization
Establishing solid communication between all of the individual catoms is a very important
first step in order to get the Claytronics test-bed to work. Localization is the next step when
it comes to getting the system to function correctly. We define localization of a catom as an
algorithmic way to determine its own position and orientation relative to its neighbors. We
emphasize that the process of localization must establish position as well as orientation, so
that the movements of a catom can be coordinated accordingly.
2.1 Existing Systems
There are many ways to establish location information, some of which are readily com-
mercially available such as Global Positioning System (GPS) units, some are less common
such as ultrasound, and some are used only for specialized applications, such as laser range
scanners. Each of these methods of localization has its own set of properties which can be
summarized as following:
• Physical vs symbolic – whether the system determines a physical location such as
latitude and longitude or whether it reports a symbolic position such as a building
name or an office number. Symbolic positions are usually built on top of the physical
ones.
• Absolute vs relative – location can be absolute or relative. An absolute location uses a
14
common coordinate system such as latitude, longitude, and altitude in GPS receivers.
In a relative system, each object can have its own frame of reference. For example, a
hand-held metal detector used to find coins in the ground – the position of the coin
will be relative to the detector.
• Local vs global – location information can be broadcast globally such as in a GPS
system, where orbiting satellites broadcast location information to anyone using them
on Earth. But location information can be also broadcast the other way – locally –
where each object broadcasts its position. Radio frequency tags that prevent shoplifting
work this way – they broadcast their position when they are near a detector.
• Accuracy and precision – location systems vary widely in their abilities as well as in
their accuracy and precision. We define accuracy as the ‘grain size’ of the position in-
formation the system can provide, e.g. 10 meter accuracy for GPS receivers. Precision
denotes how often we can expect such accuracy from the system, e.g. 95% of positions
reported by GPS for the same location will be within 10 meters.
• Scale – location systems vary in the scale of nodes they can support. Global systems
such as GPS, RF radio beacons, etc. can support an unlimited number of nodes, since
the nodes do not interfere with each other or the system in any way. On the other end
of the spectrum, active tag or bar-code based systems do not scale at all – a bar code
reader can only read one tag at a time.
These are definitely not all, but perhaps the most key properties of location systems [21].
Keeping these metrics in mind, we now turn to the actual location systems.
Active Badge [19] is one of the earliest systems. Each person tracked by the system wears
a small badge which uses diffuse infrared technology to communicate with receivers spread
around the building. Every 10 seconds each badge emits a unique identifier, which is received
by the system and processed by the central server to determine everyone’s position. The
primary difficulties are using diffuse infrared with fluorescent lighting and the short range of
infrared communication.
Active Bat [20] is similar in spirit to Active Badge, but uses an ultrasound time-of-flight
lateration technique to provide more accurate location estimation. Each Active Bat badge
15
emits an ultrasound pulse which is received by a series of receivers attached to the ceiling of
the building. The receivers communicate with the server to determine a Bat’s position with
an accuracy of 9cm.
Cricket [48] also uses ultrasound, but unlike Active Bat, it forces the objects to perform
their own triangulation computations. Cricket uses ultrasound beacons combined with radio
frequency broadcasts. The main advantage of this system is the decentralization which allows
extensive scalability.
The RADAR [4] system uses existing 802.11 WaveLANs as the means to establish location
information. The system works by measuring signal strength with regards to base stations
and since the positions of base stations are known, the position of the laptop can be estimated
with about 3 meter accuracy.
MotionStar [49] uses an entirely different approach – magnetics. A number of magnetic
coils measure magnetic field strength at predefined locations. A node that is being localized
emits a constant magnetic field, which is tracked by the infrastructure. This approach is
mostly used in motion capture due to its extreme precision of 1mm and 0.1◦ orientation, but
is costly and does not scale.
Easy Living [38] uses computer vision to perform a technique known as scene analysis.
Rather than tracking the location of all objects, the system attempts to analyze what it sees
and determine the positions of all objects based on that information.
Smart Floor [43] places pressure sensors around the building to determine where people
are currently standing. While the system is rather simple, it does not scale well and is costly.
E911 [17] is a system to locate cellular phones. It operates by measuring signal strength
of the cell phone at various stations, signal of stations at the cell phone, as well as utilizing
GPS-assisted handsets. Positioning is accurate within 150m.
Thus we see that there is a whole variety of methods to establish location information.
We also notice that there is a distinction between establishing a position information and
orientation information – most systems concentrate on the first one. This is reasonable since
it is usually more important to determine where you are driving rather than which way your
car is facing. However, establishing both catom orientation and position in Claytronics is
crucial to operation of the system. Thus it seems that while a number of current techniques
16
appear useful, none of the above methods apply directly to our problem.
2.2 Architecture and Design
As we have seen in the previous section, there are many possibilities when building a local-
ization system. After weighing all the pros and cons, we decided to use RF receiver signal
strength index (RSSI) as the means of establishing localization in Claytronics. While RF
RSSI does not provide reliable performance and has known issues of multi-path and inter-
ference, it comes at a very low cost – in fact it comes for free. This is important in several
ways – first of all it saves costs, but most importantly – it saves space, weight, and software
complexity in our system.
Position estimation based on signal strength can be performed in three distinct ways:
triangulation, trilateration, and hybrid. Triangulation refers to establishing positions based
on signal directionality which allows the node to compute relative angles between the trans-
mitters. This information is then used to determine the relative position. Trilateration is
the technique of position estimation based on distances to the broadcasting nodes, a.k.a.
beacons. Likewise, the hybrid approach usually uses the combination of the two.
Trilateration seems like the method of choice for our applications. There are several rea-
sons for that decision. One of them is that triangulation and hybrid schemes add unnecessary
complexity, since they require specialized hardware and/or antennas that can determine sig-
nal directionality. Furthermore, as we show, a trivial case of trilateration suffices for our
purposes of establishing localization of all the nodes in the system.
2.3 Hardware
Although we chose to use the signal strength method to determine the locations of the nodes
in our system, there are several other ways of localizing the nodes in Claytronics. We are
currently using wireless communication between all nodes and thus similar techniques from
the wireless world and sensor-networks become useful. However, we also keep in mind that
Claytronics could also be built on top of a wired communication layer, and thus additional
17
approaches are worth mentioning.
2.3.1 Wired vs. Wireless
As we mentioned earlier, wired communication has several important disadvantages, most
notably the need for complex routing support and additional hardware. Additional hard-
ware significantly affects the weight, reliability, and complexity of the system, while routing
support makes software more convoluted than it needs to be. However, a wired network has
one key advantage – we know where information comes from.
Utilizing some sort of wired communication in Claytronics would tremendously simplify
localization issues. In fact, location information could be trivially propagated topologically
based on the catom connectivity. Starting with a seed node and assigning it an arbitrary
position and orientation, the network would propagate the information to all the nodes, since
the distance between any two connected nodes is 2∗radius and the angle is a discrete quantity
dependent on the number of connections, e.g. for 12 magnets the angle is in 360/12 = 30◦
increments.
Wired instead of wireless communication would greatly simplify the localization process,
but at the cost of increasing the weight and size of the system, which at the moment is
not a feasible solution. Furthermore, dynamic routing seems to be a non-trivial problem
as well. For these reasons we will use wireless method for communication and establishing
localization in the current version of Claytronics.
2.3.2 Antennas
One of the key elements of any wireless RF-based localization system is the antenna. An-
tennas come in various shapes and sizes, but for our initial experiment we choose to use a
simple monopole antenna, which is essentially a piece of wire. A simple monopole provides
uniform signal strength gradient which falls off with the square of distance:
RSS ≈ 1
R2(2.1)
In several of our experiments, we have achieved a sub-centimeter precision using a tiny
18
60
65
70
75
80
85
90
95
100
0 0.5 1 1.5 2 2.5 3 3.5 4 4.5 5
Distance (cm)
Sig
nal S
treng
th (%
)
Figure 2-1: Signal strength of the monopole antenna.
1cm long antenna as shown in Figure 2-1.
However, we also noticed that Claytronics does not work in a vacuum and this wonderful
performance becomes unusable when other objects are placed between or near the catoms.
Confirming several previous studies [9, 15], RF interference and multi-path wave propagation
renders this precise method useless for short distances.
The solution to this problem is to use a circular loop antenna. While it does not provide
the impressive precision of the simple monopole, it nicely fits the cylindrical form factor of
our catoms and we can very reliable determine whether two catoms are adjacent or not.
As we demonstrate, this adjacency information is sufficient to build up a global map of the
system as well as to provide the necessary feedback.
2.4 Existing Algorithms
Many systems that are described in Section 4.1 have interesting capabilities and yet few are
applicable to sensor networks. Mostly for the reasons of costs and simplicity, sensors networks
primarily use RF RSSI localization. However, while simple and robust, this method is very
inaccurate and much better results are obtained by other methods such as ultrasound [55].
Nevertheless, as shown again and again, poor hardware can be made useful by good software.
Many interesting algorithms have been developed to utilize RSSI and produce reliable results.
One of the approaches that avoids the range error problem altogether is to only use the
connectivity between the nodes. An example of this idea is GPS-Less system [10] that uses
19
a grid of beacon nodes with known locations. Each unknown node configures its position
with respect to the centroid of beacon locations it is connected to. The position accuracy of
this method is 1/3 of the separation distance between beacons, which is much better than
pure RSSI.
Another method developed by Doherty et al [15] uses the connectiviy between nodes to
create a set of geometric constraints and solve it using convex optimizations. The resulting
accuracy depends on the fraction of anchor nodes, i.e. with 10% anchors the accuracy for
unknowns is on the order of the radio range. A serious drawback of this algorithm is that
the convex optimizations are performed by a single centralized node.
DV-Hop algorithm [42], in contrast, is completely ad-hoc and has no centralized com-
ponents. The algorithm starts by having anchor nodes flood their locations to all nodes in
the network. After that each unknown node records the position and minimum number of
hops to at least three anchors. Whenever one anchor infers the position of another anchor,
it computes the distance between them, divides it by the number of hops, and floods this
average hop distance into the network. Each unknown uses the average hop distance to
convert hop counts to distances, and then performs triangulation to three or more distant
anchors to estimate its own position. This algorithm works very well in dense and regular
topologies.
Approaches such as MDS-MAP algorithm [56] use interesting ideas such as multidimen-
sional scaling and achieve even better results in terms of position errors. However, one major
problem of this algorithm is that it requires global information of the network and central-
ized computation. Hop-Terrain [54] is yet another position estimation algorithm, similar to
DV-Hop.
AFL algorithm [47] shows a good example of an algorithm which is anchor-free as well as
concurrent. The difference between anchor-based algorithms and anchor-free ones is whether
the algorithm requires an initial number of nodes to know their positions before the algo-
rithm can proceed with the localization of the entire system. Anchors provide the algorithm
a significant performance benefit, but at the cost of requiring the initial bootstrapping. Lo-
cation algorithms can also be categorized as incremental and concurrent – whether all nodes
in the system can make progress simultaneously or have to wait for others nodes to establish
20
their location.
An algorithm developed by Nagpal et al [40] presents an interesting way to create a global
coordinate system without the use global control, globally accessible beacons, or accurate
estimates of inter-sensor distances. The algorithm starts with seed nodes sending gradients
to all neighbors – these gradients propagate through the graph in a breadth-first-search
fashion. A multilateration algorithm is applied to combine position estimates based on at
least three different seeds. One of the main points of this work is the critical minimum
average neighborhood size of 15. This algorithm and the ideas behind it seem applicable to
our system as well.
We see that there are numerous positioning algorithms just as there are many hardware
implementations. Many positioning concepts are definitely useful, in particular methods that
use connectivity-only information; however none of these methods can be applied directly to
our problem for various reasons, most notably the fact that almost none of these algorithms
address the issue of orientation of the nodes. Also, our system has one important advantage
which is far less common in sensor-networks – lattice alignment. As we show in the following
section, a Claytronics system forms a self-aligned regular lattice due to uniform placement
of magnets on the catoms. Thus we will try to leverage this lattice topology as much as
possible and incorporate it into our algorithms. We will eventually present a topology-based
algorithm which is fast, anchor-free, concurrent, and fully distributed.
2.5 Simulation
As we begin to develop localization and other distributed algorithms for Claytronics, we
realize an acute need to model and simulate these approaches. Furthermore, while some
algorithms sound interesting, they would be far more convincing with some experimental
results. So in order to do that, we have created a simulation based on the physically-based
model of the catoms. The goal of the simulation is not to create a 100% sound model of
magnetics or achieve perfect modeling accuracy, but rather give us a tool which can be used
to visually simulate a large-scale formation of catoms performing some distributed algorithm.
Furthermore, the simulation is optimized for speed rather than precision.
21
(a) (b)
Figure 2-2: Force field of (a) bar magnet and (b) point charges.
2.5.1 Physically Based Model
One of the most important decision in creating a physically-based model in computer graphics
is to determine which approximations are reasonable to assume in a given case. Each catom is
a remarkably complicated piece of electronics, magnetics, and computing capable of wireless
communication, onboard processing, and motion around other catoms. However, for the
purposes of this simulation, we will assume that a catom is a simple cylinder. As such, the
catom’s physical behavior can be completely described at any moment as a vector of
[x, v, θ, ω] (2.2)
where x is position, v is velocity, θ is orientation, and ω is angular velocity. Now that
we are modeling each catom as a cylinder, the next question is to how to model each of
the magnets on the catom. The catoms can potentially have 6, 8, 12, 24, etc. number of
magnets, so the simulation must be flexible and allow us to easily change such parameters.
The force distribution of a true bar magnet is a very sophisticated phenomenon; however,
at the ends of the magnet these forces can be roughly approximated as point charges as
shown in Figure 2-2. Since the force of the magnetic field decreases as the inverse cube of
the distance, this approximation is reasonable.
In order to compute the interaction between the catoms, we compute the interaction
between every pair of magnets on all the pairs of catoms. That is for each catom i, we
compute the forces and torques on the catom by each of their magnets due to the attraction
or repulsion on each of the magnets of all other catoms as shown in Figure 2-3. The force
between each individual pair of magnets is computed as following:
22
cF
cM
L
mix
njx
ixmF
Figure 2-3: Magnet interaction between catoms.
Fm = − L
|L|km1
|L|3 (2.3)
Where xmi and xn
j are positions of m-th magnet of catom i and n-th magnet of catom j
respectively, and L is the vector between them, i.e. L = xmi − xn
j as shown in Figure 2-3.
Thus the magnetic force is in the direction between the two magnets and is proportional to
the inverse cube of the distance. If the polarity of the magnets is the same, the force faces
the opposite direction.
The catoms can slide along the table, but they can also turn. We compute the net force
and torque due to each of the magnets as following.
Fc = Fm (2.4)
τc = M × Fm (2.5)
Where M is the vector from magnet m of catom i to the center of catom i and L is the
vector from magnet m of catom i to magnet n of the neighboring catom j, i.e. M = xmi −xi
as shown in Figure 2-3. Therefore the resulting force F on the catom is in the direction of
the magnets and proportional to the dot product of M and L. In other words, if the catom
is being pushed at the center it will move, whereas if it pushed at the side it will turn. The
torque is computed as the cross product of lever arm M and the force Fm.
External forces such as gravity can be easily changed in the simulation and the default is
the usual F = mg. Static and kinetic frictions are modeled as well in order to provide more
realistic behavior of the model. The friction equations are simply:
23
Fs = µsN (2.6)
Fk = µkN (2.7)
Where µs and µk are static and kinetic friction coefficients and N is the normal force, i.e.
the weight of the catom. Therefore, the net force and torque on the catom is the following:
Fnet = mg + Fs + Fk +∑j
∑m
∑n
Fc (2.8)
τnet =∑j
∑m
∑n
τc (2.9)
From these forces we compute the acceleration and the angular acceleration of each catom:
a =Fnet
m(2.10)
α =τnet
I(2.11)
where I is the inertia of the catom, which for a cylinder is Iz = 12mr2. Therefore we now
can compute both linear and angular acceleration for the system at any point in time. The
entire system is time stepped. We compute the linear and angular velocities and positions
at the next step by integrating the accelerations at the present step.
2.5.2 Collision Detection and Response
One obvious issue in this simulation is that catoms are almost constantly colliding or are
in contact with each other. Thus this means that we need to detect as well as resolve all
these collisions in order to keep the integrity of the simulation. A true precise rigid-body
collision detection and response for large scale system is rather complicated and cumbersome
to implement. The problem mainly in our case is not detection, but response – collision
detection can be trivially implemented by determining whether any two catoms are less than
2 ∗ radius distance away from each other. If they are, then they are colliding and something
has to be done about it.
As we mentioned earlier, true rigid body collision response is complicated and slow.
24
Collision Spring
vF
Figure 2-4: Collision detection and response using penalty forces.
For this reason, we will assume that all catoms are slightly deformable. This assumption
is not unreasonable – for example, we could put a thin rubber band around the catoms.
Keeping this in mind, we use a quadratic penalty force method to resolve collisions in our
simulation [5].
The penalty force is a force exerted by an imaginary collision spring when an object
penetrates another object. Figure 2-4 shows a small ball moving towards and eventually
hitting an octagon. The collision spring is put between the two objects such that it exerts
the force pushing the ball out of the octagon. This force will slow down the ball to a halt,
and since the force will be present and proportional to the square of the distance penetrated,
it will reverse its velocity such that the ball will start moving in opposite directions and thus
end the collision.
The penalty force is modeled using two components – quadratic spring force and damping.
Damping is necessary because it is present in all springs in the physical world, but also
because it prevents oscillations and numerical disturbances during the simulation. These
components are modeled as follows:
Fspring = − L
|L|kc(2r − |L|)2 (2.12)
Fdamp = − L
|L|dc(vi − vj) · L (2.13)
Fpenalty = Fspring + Fdamp (2.14)
We note that damping force depends linearly on the relative velocities of the colliding
25
objects, this comes from the physics of simple harmonic motion mx + bx + kx = 0 and
Hooke’s law, F = −kx.
2.5.3 Implementation Details
The simulator is implemented in C++ and has a generic framework capable of re-computing
arbitrary forces for arbitrary number of catoms with arbitrary number of magnets using
several possible integrators. Each catom has the following properties in the simulation:
struct Catom {
Vector position;
Vector velocity;
Vector acceleration;
double theta;
double angVelocity;
double angAcceleration;
char magnetPolarity[MAGNETS_PER_CATOM];
};
where magnetPolarity denotes whether the electromagnets are off (O), north-south (N),
or south-north (S). In addition to that the simulation has parameters to control catom’s
mass, inertia, static and kinetic frictions, etc.
The system supports a number of integrators: Forward Euler, Leap-Frog, and 4th order
Runge-Kutta. After several experiments it became clear that simpler integrators are too
unstable and that Runge-Kutta is the only reasonable solution to this problem.
We notice that we are computing magnet-to-magnet pair-wise interactions. Assuming
that a simulation has n catoms with m magnets each, this comes out to O((mn)2), which
is rather expensive and does not scale. In order to alleviate this problem, we subdivide
the simulation into voxels and perform magnet force computations only within those voxels.
This approach is commonly used for particle systems in computer graphics and reduces
26
0
2
4
6
8
10
12
14
0 50 100 150 200 250
Number of nodes
1/FP
SAll Pairs
Voxels
Poly. (Voxels)
Linear (All Pairs)
Figure 2-5: Frame-rate comparison of all-pairs and voxels.
the running time to O(kmn) where k is the average number of particles per voxel. As
illustrated in Figure 2-5, such technique not only provides significant performance gain, but
also eliminates numeric errors due to magnets far away. Magnetic force is proportioinal to
the inverse cube of distance and thus will be infitesimal at large distances and thus can be
simply ignored.
2.5.4 Results
The simulator implementation and testing is complete and the simulator can reliably model
interaction between many catoms. The visual component of such simulation is very impor-
tant since it gives us a good way to spot algorithm errors and also because we can clearly
observe the behavior of the system.
A typical screen shot of the simulation is shown in Figure 2-6. Catoms are rendered
as cylinders with magnets near the border. The simulation also displays several current
parameters and important variables such as catoms’ mass and friction, integration method,
and simulation timestep.
27
Figure 2-6: Simulation screen shot.
28
Chapter 3
Localization Algorithms
3.1 Establishing Position
Although it might seem insufficient at first, adjacency information can tell us a lot about
the configuration of the system. In particular, since our system forms a mesh, many of the
computer graphics techniques become applicable to this problem as well [60, 63].
First of all, we notice that any possible configuration of the Claytronics system will form
either a square or hexagonal mesh. The reason for that is that spheres or cylinders of uniform
diameter will form a dense mesh with six neighbors in two dimensions. This observation tells
us that for any catom it will have at most 6 neighbors and that the entire system will form a
lattice as shown in Figure 3-1. This also means that any three adjacent catoms will form an
equilateral triangle in a hexagonal lattice and any four adjacent catoms will form a square
in a square lattice.
Now, determining the shape of the system is actually feasible. We start by selecting
(a) (b)
Figure 3-1: Claytronics (a) square or (b) hexagonal lattice.
29
B
C
D
B
C
D’DA
A
Figure 3-2: Computing position of node D using nodes A, B, and C as reference.
three connected nodes as seed or anchor nodes – they will be used as a single reference
point for establishing local position and orientation information for the entire lattice. Thus
these nodes must know their location and orientation prior to start of the algorithm. Notice
however, that since anchor nodes are only used to establish a local coordinate system, the
position and orientation of each anchor can be arbitrary as long as it is consistent with other
two anchors, e.g. two adjacent nodes cannot both have the same position. We will describe
how to generate such anchors in the next section.
After the seed nodes are selected and located, we find any node which is connected to any
of the two seed nodes. Since we have the adjacency information, we know that the nodes
form an equilateral triangle since they are interconnected and the positions of initial two
nodes are known as well. Therefore the position of the new node can be computed by simple
vector math as shown in Figure 3-2.
We see that there are two possible positions for the new node: D and D′. However, one
of these positions is taken by a localized node already, i.e. A in this case. So we send a
message to the nearby localized nodes asking them if there is anyone at the first possible
positions, i.e. D. Node A will reply with a ‘yes’ to D position, which means that the node
must be placed at the second position, i.e. D′. If all of the nodes were silent we would use
the first position.
By repeating the above procedure for all of the nodes in the system we get the actual
mesh representation of the system and therefore the shape that system represents. We
implemented a software simulator to validate this algorithm and as we can see from Figure
3-3, this method does indeed work.
30
Figure 3-3: Step-by-step lattice construction.
As we can see, this iterative process successfully solves localization problem when catoms
are packed in a hexagonal lattice. However, it does not address one important issue – the
orientation of the catoms. As we can obviously see, static location information does not
provide any means to establish orientation – there is simply no data addressing the angles at
which catoms are facing each other. This missing piece of information is critical to locomotion
mechanism of Claytronics – unless the catoms know which way they are facing, they cannot
coordinate their magnets and thus the whole system becomes immobile. We will address
this issue in our proposed algorithms below.
The speed of the above algorithm is O(√
n), since the algorithm propagates in a circular
fashion assuming that the seed is roughly in the center.
3.2 Actions and States
Localization via mesh construction described in the previous section is definitely sufficient for
the catoms to create a representation of the system. However, running the full localization
algorithm every time a catom decides to move is not practical due to time complexity of
the algorithm. In order to avoid this problem, we notice that each action in the current
Claytronics framework has a predefined next state. For example, if a catom chooses to
rotate 60◦ to the right – we will know exactly where it should end up even before the catom
starts to move. Thus it follows that if we know the initial configuration of the system and can
accurately keep track of all the actions of the catoms, we can actually keep the shape of the
system up-to-date without any localization at all. This means that we will use localization
and adjacency information only for initial mesh construction when the system initializes and
for feedback sensing when the catoms move to ensure that all the movements are successful.
31
A0,2,0
0,1,0
1,1,0
B1,2,0
0,0,0
1,0,0
2,1,0
C2,2,0
2,0,0
0,1,0
1,1,0
B1,2,0
0,0,0
1,0,0
2,1,0
C2,2,0
2,0,0
A1,2,60
0,1,0
1,1,0
B1,2,0
0,0,0
1,0,0
2,1,0
C2,2,0
2,0,0
A1,3,120
X
Y
0,1,0
1,1,0
B1,2,0
0,0,0
1,0,0
2,1,0
C2,2,0
2,0,0
A2,3,180
0 1 2
0
0
1
1
2
2
Figure 3-4: Actions and states.
We notice that using the state-based approach described in this section requires that all
catoms have valid position information at all times. Thus if several catoms have incorrect
position data, the location information in the entire lattice will quickly become inconsistent
as well, since the catoms constantly update their position based on their current position and
the position of their neighbors. The Claytronics system is not perfect and therefore such
errors in representation will sometimes arise. However, there are several ways to recover
from inconsistent system state. The obvious approach is to rerun the global localization
algorithm and reassign positions to all catoms. This approach is the last resort, since it is
computationally expensive. Another solution is to perform consistency checks every time a
catom moves. For example, if a catom has 6 neighbors, it will validate that the neighbors
are positioned in a circle and connected to each other.
In order to keep track of all the actions and states, we assign our framework a virtual
coordinate system. Assuming that all the catoms form a hexagonal lattice, we can represent
location of any catom by its discrete 2D position and orientation in 60◦ increments: (x, y, θ)
as shown in Figure 3-4.
Therefore if a catom A decides to rotate 180◦ around its right neighbor B – the catom
will know exactly where it will be during each step. Thus it will update its local coordinates
as it moves – notice that this can be performed with or without any feedback.
One of the common issues in regards to the locomotion in Claytronics is determining
whether a catom is allowed to rotate or not. The answer is based on whether there is
32
another catom blocking the movement. Furthermore, if the movement is allowed, the catom
will need to coordinate the movement with its neighbors since they might need to adjust
magnet polarities to perform the movement. This issue requires us to have a way to convert
locations into catom IDs and vice-versa.
We call the function that performs this action a Consistent Naming Function (CNF ).
CNF works as follows: it takes a catom ID, broadcasts this catom ID to all nearby catoms,
and then the node with this ID replies back with its location. Likewise, CNF−1 takes a
location with or without orientation, broadcasts it to all catoms, and the catom at this
location replies with its catom ID. In the example above, at its final stage, the following
equalities will hold:
CNF (A) = (2, 3, 180), CNF−1(2, 3, 180) = A, and CNF−1(2, 3, ∗) = A.
This approach becomes slightly more complicated if the catoms are allowed to form square
configurations in addition to the hexagonal ones, but the method can still be used to keep
the localization information consistent.
The important part about CNF is that it is essentially stateless with regards to the
topology of the system. Only per-catom position and catom ID information is stored on
each catom. Contrary to the complex routing approaches which require knowledge of the
topology in order to determine their position, CNF allows us to perform position-related
operations without keeping any state - CNF will correctly convert between catom numbers
and their positions as long as all the catoms follow the consistent numbering protocol. We
will keep the concept of CNF in mind as we design different algorithms for locomotion and
path planning in Claytronics.
3.3 Virtual Anchor Generation
We have mentioned that the positioning algorithm starts with a single anchor; however,
we did not describe how to generate its position and orientation. One possible solution is
to pre-configure a certain node to be the seed and assign it a real physical position and
orientation. However, we notice that the relative position and orientation of the catoms in
Claytronics is more important than absolute – thus we can use a virtual coordinate system,
33
with the anchor node being set to an arbitrary position and orientation.
3.3.1 Single Anchor
In this case we will assume that we start with a single seed positioned somewhere inside the
lattice of nodes. Since we need at least three seeds to establish a coordinate system in 2D,
the initial single seed needs to select two more nodes as seeds. Thus the initial seed picks
two of its neighbors that are adjacent to each other.
Now the initial seed has two adjacent neighbors and we can assign them coordinates.
The initial seed itself becomes (0, 0) and its neighbors become (1, 0) and (cos(60◦), sin(60◦))
respectively for a hexagonal lattice. These three nodes will act as spanning vectors for their
local coordinate space.
After establishing seed positions, the next step is to establish their orientation. In order
to do so, the initial seed sends a message to its two neighboring seeds requesting that one
seed turns all the magnets North and the other seed turns all the magnets South. Now
the initial seed toggles all of its magnets North one by one while watching for the change
in connectivity with the two other seeds. Once the connectivity changes the initial seed
will know which magnet is connected to the other seed. This magnet scanning procedure is
repeated with the South polarity as well, to determine to which magnet the other seed is
connected.
Now the three seeds know their positions as well as orientations, which is sufficient to
establish localization information for the entire lattice as shown earlier.
One potential problem with this algorithm is that the seed nodes close to the center of the
shape cannot move, because there are too many other nodes surrounding them. Therefore
these seeds cannot establish their location. We address this issue in Section 4.4.3.
This approach can be improved by starting with multiple seeds and by selecting seeds
which are not close to the boundary. However, in order to select the seeds which are close
to the center, we first need to determine where the center is.
We notice that boundaries of the system can be trivially computed by selecting all the
nodes that have fewer than 6 neighbors. Furthermore, the performance of any such localiza-
tion algorithm will be O(1) since we are simply looking at the list of our neighbors. Thus
34
00
10
01
21
1
00
0
110
0
000
0
0 0 0
Figure 3-5: Determining boundaries and center of the shape.
we can quickly compute the boundary of the system.
After the boundary is computed, each boundary node sends a message to its neighbors
telling them its distance from the boundary, i.e. zero. When neighbors of the boundary nodes
receive this message, they send it to their neighbors with a distance of 1. This inwards BFS
algorithm continues until all the nodes have a distance number. Any node with largest
distance from the boundary is selected as the first seed and any of its two neighbors are
selected as the other two seeds as shown in Figure 3-5. Thus we can select a 3-seed kernel
for localization which will be close to the center of the shape. The running time is again
O(√
n).
3.3.2 Multiple Anchors
The seeds are distributed randomly and uniformly throughout the Claytronics lattice. The
simplest way to generate seeds is most likely by catomID, since each catom has a unique
identifier. The very first step of the algorithm is for seeds to check whether they are bordering
with other seeds – if this is the case, then one of the seeds should not be a seed, since it
will interfere with the kernel generation of the other seed. Although this case is rare, it does
happen and such collisions are resolved by a random draw, such that one of the seeds will no
longer be a seed. Now each seed picks two of its adjacent neighbors as the other two seeds
of the kernel. Again, the seeds check for collisions and resolve them by eliminating one of
the colliding kernels.
Similarly to the single-anchor version, each initial seed has two adjacent neighbors and
we assign them coordinates. The initial seed itself becomes (0, 0) and its neighbors become
(1, 0) and (cos(60◦), sin(60◦)). Each kernel generates a unique clusterID using the catomID
35
A
C
B
A(0,0)
A(1,0)
A(.5,.8)
C(0,0) C
(1,0)
C(.5,.8)
B(.5,.8)
B(0,0)
B(1,0)
Figure 3-6: Automatic kernel generation from seeds.
of the initial seed – this clusterID will be sent to every node that is acquired into the cluster.
The clusterID will most likely be transmitted via slow local communication and index into
a table of possible frequencies assuming that we are using multiple frequencies for broadcast
transmissions. If only one frequency is used, then the clusterID will simply identify the
cluster.
This generation of kernels from seeds is demonstrated in Figure 3-6.
3.4 Uniform Lattice Algorithm
We now present the first functional algorithm that can be used to establish the position and
orientation of all catoms in the Claytronics system. This algorithm assumes that the initial
configuration of the system is a uniform hexagonal lattice – a reasonable assumption since
we will most likely put all the nodes in one big pile when initializing the system. In terms
of sensing and feedback capabilities we will use RSSI which will be able to tell us whether
any two catoms are adjacent or not. We also assume that the locomotion capabilities of the
nodes are electromagnets with three distinct end-point states: Off, South, and North.
3.4.1 Procedure
The underlying component of this algorithm is the dipole invariant, defined as following:
36
Figure 3-7: Dipole invariant.
Dipole invariant: if a catom wants to turn on its magnets and mark itself as localized,
then the polarities of its magnets must align in a dipole fashion (half of the magnets are
South and half are North) with all other already localized.
The idea behind dipole invariant is illustrated in Figure 3-7. We see that if all catoms
follow this procedure, then the entire lattice will be fully connected. Furthermore, keeping
this invariant allows catoms to perform movements with little coordination with the neigh-
boring catoms, since their positions are known and their magnet polarity configurations can
be inferred from their positions. Keeping this concept in mind, we can now outline the steps
of the algorithm:
1. All catoms are pushed together to form a hexagonal mesh. 3 kernel catoms are posi-
tioned in the center of the mesh and are aligned in the same direction.
2. All catoms establish their positions using the lattice scheme introduced in Section 4.4.
3. The 3 kernel catoms turn on their magnets in the dipole fashion.
4. Now each catom performs the following actions while not all catoms are localized:
If a catom is localized:
Then it sends a message to its neighbors saying that it is localized.
If a catom receives a message saying that one of its neighbors is localized:
The catom marks this neighbor as its reference catom N . The catom now pulses its
magnets with North polarity one by one watching for loss of connectivity with the
37
(a) (b) (c)
Figure 3-8: Initial algorithm: (a) 3 seeds, (b) spread, and (c) final configuration.
reference catom. If this does not happen after all magnets are pulsed, this means that
the neighbor is connected to us with the opposite polarity, so we repeat the pulsing
procedure again but with a South polarity.
The catom now knows that it is connected to the neighbor N at its magnet M with
polarity P . Since we know the position of the neighbor and our position, the neighbor
is dipole-aligned, and we know at which magnet we are connected – we have all the
information to align ourselves with the neighbor.
Example: Catom is at (1, 1), the neighbor is at (1, 2), and we are connected to the
neighbor at magnet 2 with neighbor polarity S. Assuming that we have 6 magnets, this
means our orientation is −60× 2 = 120◦, since if we had an orientation of 0◦ we would
be connected to the neighbor at magnet 0. This means that to align ourselves to the
dipole environment, we need to set our magnets to [NNSSSN] shifted right by 2 which
is [SNNNSS].
5. All catoms are correctly localized – i.e. positioned and oriented.
3.4.2 Results
To illustrate the feasibility of the above algorithm as well as to determine its true perfor-
mance, we modeled the algorithm using our simulator. We start with the initial 3 kernel
nodes positioned roughly in the center of the square hexagonal lattice as shown in Figure
3-8. After the initial nodes are configured, we start the algorithm exactly as outlined in the
previous section.
38
(a) (b) (c)
Figure 3-9: Improved bidirectional algorithm: (a) 3 seeds, (b) spread, and (c) final configu-ration.
y = 7.1x0.6
y = 6.8x0.5
y = 4.1x0.5
0
20
40
60
80
100
120
140
160
180
200
0 50 100 150 200 250
Number of nodes
Tim
e (ti
cks)
Center - UnidirectionalSide - UnidirectionalCenter - BidirectionalPower (Center - Unidirectional)Power (Side - Unidirectional)Power (Center - Bidirectional)
Figure 3-10: Performance of several variations of the Lattice algorithm.
As shown in Figure 3-8 and Figure 3-9, the algorithm does indeed perform correctly and
quickly localizes the nodes in the mesh. However, we notice in Figure 3-8 that the nodes on
the far end of the mesh are localized significantly faster than the nodes on the near end (from
viewers perspective). This is due to the fact that each node attempts to pulse its magnets
with North polarity and then South polarity – however, since the nodes on the far end will
always find its neighbors with North polarity and the nodes on the near end will always find
its neighbors with the South polarity, we see that it roughly takes 2X longer for the bottom
nodes to establish localization than the top nodes. Thus the algorithm spreads in a conical
fashion rather than the expected circular pattern.
Further examining this issue, we ran simulations with the initial kernel nodes being posi-
39
tioned on the near end of the lattice and letting it spread conically instead. The performance
was significantly better – an improvement from O(n0.6) to O(n0.5). Taking advantage of the
knowledge that the neighbors above us will have South polarity and below us will be North,
we modified the algorithm such that if our reference catom was above us we would use a
South polarity first. This bidirectional algorithm did not change the O(n0.5) running time
limit, but it did improve the multiplicative factor by 2X as shown in Figure 3-10.
To summarize, we have developed an algorithm which can successfully establish localiza-
tion information in a mesh-like network with a runtime of:
runtime = O(√
n)
(3.1)
3.4.3 Analysis
There is one aspect of this algorithm which might present difficulties during the physical
implementation and thus is worth examining. We assume that the nodes establish their
orientation by observing changes in connectivity when they pulse their magnets and thereby
move a tiny distance away from their neighbors.
This approach has two inherent issues. The first is that in order to notice a significant
change in RSSI the distance the catom will need to move away from another catom will most
likely be significant, e.g. several millimeters. Furthermore, in order to do so reliably and
avoid RF-related issues, that distance might even be larger than this estimate.
The second problem arises from the fact that if the catoms need to move in order to
establish orientation, they must be located close to the boundary of the shape. In other
words – catoms in the center of the shape cannot establish their orientation, because they
are surrounded by millions of other catoms and thus are completely immobile.
Such constraints on catom movements imply that we will most likely only establish
localization information for catoms that are close to the outside of the shape. It also means
that catoms deep inside the shape will not be localized. However, the catoms inside are
inherently immobile and thus have no use of localization information anyway, so this should
not present any major difficulties to the overall goal of the algorithm.
We also notice, that this issue can be avoided altogether if the catoms are designed in
40
XA
YA XB
YB
BP2AP2
APBORG
{A}
{B}
P2
P1BP1
AP1
Figure 3-11: Coordinate frame mapping.
such a way that we can establish connectivity information without moving the catoms. This
can be accomplished by mounting the magnets on flexible chassis or adding some simple
feedback mechanism to the system.
3.5 Distributed Localization
The above algorithm demonstrates a reasonable performance for medium-scale version of the
system with hundreds or thousands of nodes. However, as the size of the nodes decreases
and we move into multi-million node configurations, the O(√
n) runtime is no longer feasible.
This is why we developed a much faster algorithm which can scale well for any number of
nodes.
We notice that the bottleneck of the previous algorithm is the radial propagation of
location information. In order to mitigate that problem, we will start the algorithm with
multiple seeds. Each seed will pick two neighbors to create an initial 3-seed kernel, which will
grow into a cluster of nodes with location information relative to the kernel. Each cluster
formed around each seed will have its local location information rather quickly, since they
can all compute it in parallel. The challenge now is how to effectively merge all these clusters
into one system.
Each initial seed essentially represents the origin of its cluster’s coordinate frame. Like-
41
wise, all nodes in the cluster are localized with respect to that local coordinate frame. In
order to transform a location from cluster B into a location in cluster A, we need at least
two points localized in both clusters, such that we can establish the mapping according to
the following transformation matrix as illustrated in Figure 3-11:
⎡⎢⎢⎢⎢⎢⎣
Ax
Ay
1
⎤⎥⎥⎥⎥⎥⎦ =
⎡⎢⎢⎢⎢⎢⎣
cos(θ) sin(θ) x
−sin(θ) cos(θ) y
0 0 1
⎤⎥⎥⎥⎥⎥⎦×
⎡⎢⎢⎢⎢⎢⎣
Bx
By
1
⎤⎥⎥⎥⎥⎥⎦ (3.2)
Where (x, y) is the relative distance offset between the origins of the frames and θ is the
relative orientation.
We define Cluster Boundary Nodes (CBNs) as nodes that have localization information
from two different seeds and are positioned with respect to two clusters. These nodes have
location information in two different coordinate frames and thus two CBNs are needed to
merge the coordinate frames in 2D. CBNs must communicate with each other to solve system
of equations that is needed to establish transformation matrix in 2D. The first CBN tells the
second CBN that (Bx1,By1) maps to (Ax1,
Ay1). The second CBN computes cos(θ), sin(θ),
x, y based on (Bx1,By1) to (Ax1,
Ay1) and (Ax2,Ay2) to (Ax2,
Ay2) mappings.
Essentially the CBNs need to solve the following system of equations:
⎧⎪⎪⎪⎪⎪⎪⎪⎪⎨⎪⎪⎪⎪⎪⎪⎪⎪⎩
Ax1 = Bx1cos(θ) + By1sin(θ) + x
Ay1 = −Bx1sin(θ) + By1cos(θ) + y
Ax2 = Bx2cos(θ) + By2sin(θ) + x
Ay2 = −Bx2sin(θ) + By2cos(θ) + y
(3.3)
This system can be easily solved to obtain the following solution:
cos(θ) =(Ax1 − Ax2)(
Bx1 − Bx2) + (Ay1 − Ay2)(By1 − By2)
(Bx1 − Bx2)2 + (By1 − By2)
2 (3.4)
sin(θ) =(Ax1 − Ax2)(
By1 − By2) + (Ay1 − Ay2)(Bx1 − Bx2)
(Bx1 − Bx2)2 + (By1 − By2)
2 (3.5)
x = Ax1 − Bx1cos(θ) − By1sin(θ) (3.6)
42
y = Ay1 − Bx1sin(θ) − By1cos(θ) (3.7)
Notice that cos(θ) and sin(θ) are computed directly without any use of trigonometric
function such as cos and sin in order to speed up the computation on small processors.
We now have a transformation matrix T which we can broadcast to all nodes in cluster
B so that they will map their locations into cluster A and become members of cluster A.
Upon receipt of T , all nodes re-compute their positions simultaneously and instantly merge
into the new cluster. This broadcast is the key behind the speed of the algorithm.
3.5.1 Procedure
Keeping the coordinate frame transformation idea in mind, we also notice that we can merge
multiple clusters at the same time. In fact, a cluster can absorb all of its neighbors in a single
step, since all CBNs will know the necessary information already and all they need to do is a
quick broadcast to their respective clusters. This implies that in a single step, we can merge
all of our neighbors and thus essentially decrease the number of clusters by 7X assuming
that each cluster has 6 neighbors on average.
This results in the following algorithm:
1. Seed nodes start localization on a small depth. All nodes use their own frame of
reference with the seed node at (0, 0).
2. Nodes are now in small clusters and CBNs nodes know transformations from cluster
to cluster.
3. CBNs send transforms to bordering clusters.
4. All clusters perform 6-way merge to assemble the next generation of clusters – a cluster
absorbs its directly neighboring clusters to form a new large cluster.
5. Algorithm is repeated until all clusters are merged into one big cluster. Note that at
every point CBNs have up-to-date transforms, since transforms are sent via broadcast.
43
Figure 3-12: Steps taken by the scalable localization algorithm.
44
3.5.2 Results
The steps taken by the algorithm are illustrated in Figure 3-12. As we can see, the majority
of nodes are localized very quickly – essentially in 3 steps. We will now explain the speed
behind this algorithm.
In terms of evaluating the performance of the algorithm, we notice that it heavily relies
on broadcast, i.e. that a billion nodes can update their positions simultaneously. So the main
bottleneck is no longer computing connectivity information, but how fast we can propagate
transformation matrices.
Assuming that we have a fraction of nodes f as the seeds and we have n nodes total, the
initial localization for each small cluster will take O(√
k), where k is the size of the cluster,
i.e. k = nfn = 1
f. Thus it will take O
(√1f
). The process of merging the clusters will be
O(log7(fn)) since the size of each cluster grows 7X each time they merge. Although, we
realize that this is a rather ideal scenario assuming that seeds are perfectly positioned and
everything grows uniformly, but it is probably not too far off if we have randomly distributed
seeds and a reasonable initial cluster size. Thus the total theoretical running time is
O
(√1
f+ log7(fn)
)(3.8)
Which is essentially O(log7(fn)). For comparison with the previous algorithm, we can
now localize one million nodes in 7 steps as opposed to 1000 steps.
We mentioned that this scheme works assuming that we have a reasonably fast broadcast.
This is particularly crucial for the early steps of merging, when there are many small clusters
that need to use broadcast. Each CBN needs to send 2 messages per cluster merge. There
are roughly fn cluster merges, so for example, for one million nodes at 1% seed rate, that
is 10000 messages. Each message needs 4 bytes of location information for a small cluster.
So that would be 40 Kbytes. We can send that in 50ms on Bluetooth. Thus we will need
less than a second to localize a million nodes, which is a good performance for all practical
purposes of the current version of the system.
One potential issue of this algorithm is that it assumes that each cluster can perform a
broadcast simultaneously. This should not be a problem assuming that each cluster operates
45
on a slightly different frequency and clusters change frequencies as they merge into other
clusters. However, if this is not the case and only one catom can broadcast at a time, the
performance will become O(√
( 1f) + fn + fn
7+ fn
72 + fn73 + ...
), which converges to
O
(√1
f+ fne1/7
)(3.9)
This will localize a million nodes in 200 steps – much worse than 7 steps for the simul-
taneous broadcast, but still a 5X improvement over the initial algorithm.
We have mentioned the parameter f – the fraction of nodes that start out as seeds. The
performance of the algorithm as a function of f and n assuming multi-frequency broadcast
is shown in Figure 3-13 (a). We see that as f becomes small – the performance degrades as
we essentially move to O(√
n) performance. However, as f becomes large and reaches 100%,
the performance does not degrade since now we essentially have O (log7(n)) performance.
The graph of single-frequency broadcast performance is shown in Figure 3-13 (b). Likewise,
the performance degrades for small f , however now the performance also degrades for large
f , since now we move closer to O(n) when all nodes need to perform a broadcast which slows
down the system.
The optimal seed fraction f for multi-frequency broadcast is 1.00. The optimal f for
single-frequency broadcast is shown in Figure 3-13 (c) and is the solution to differential
equation:
∂p
∂f
(√1
f+ fne1/7
)= 0 (3.10)
which is
f =1
(2e1/7n)2/3
(3.11)
Figure 3-14 shows a comparison between the original algorithm and multi-frequency/single-
frequency broadcast algorithms. As we can see, this algorithm provides a significant perfor-
mance gain in both cases.
46
200000
400000
600000
800000
1 106
Number of Nodes0.2
0.4
0.6
0.8
1
Seed Percentage
6
7
8
9
Performance
200000
400000
600000
800000Number of Nodes
(a)
200000
400000
600000
800000
1 106
Number of Nodes0.2
0.4
0.6
0.8
1
Seed Percentage
0
250000
500000
750000
1 106
Performance
200000
400000
600000
800000Number of Nodes
(b)
200000
400000
600000
800000
1 106
Number of Nodes0.00005
0.0001
0.00015
0.0002
Seed Percentage
100
200
300
Performance
200000
400000
600000
800000Number of Nodes
(c)
Figure 3-13: Performance of (a) multi-frequency broadcast, (b) single-frequency broadcast,and (c) optimal single-frequency braodcast.
47
2000 4000 6000 8000 10000Number of Nodes
20
40
60
80
100Performance ticks
2000 4000 6000 8000 10000Number of Nodes
20
40
60
80
100Performance ticks
2000 4000 6000 8000 10000Number of Nodes
20
40
60
80
100
Performance ticks
(a) (b) (c)
Figure 3-14: Performance of (a) the original algorithm, (b) single-frequency broadcast, and(c) multi-frequency broadcast.
3.5.3 Analysis
The algorithm presented in this section has two theoretical running time bounds based on
the hardware used to implement it – an upper bound of O(log7(n)) for multi-frequency and
a lower bound of O( 3√
n) for single-frequency. Since the number of concurrent broadcast
connections on a single system is most likely to be limited and using a single broadcast
frequency for the entire system is not feasible, the actual running time of the algorithm will
most likely lie somewhere within the above range. Therefore:
O(log7(n)) ≤ runtime ≤ O(
3√
n)
(3.12)
We notice that we are using the speed of the algorithm as the primary performance
metric. This choice of evaluation is justified by the massive size of the system and the fact
that magnets will most likely provide sufficient alignment for the nodes, so that the accuracy
of the algorithm is not the primary concern. However, as the system grows in size, positioning
errors will definitely accumulate and might affect the effectiveness of the algorithm.
Another aspect of this algorithm that perhaps deserves special attention is the fact that
a single CBN broadcasting incorrect transformation matrix is sufficient to destroy the align-
ment of the system. As stated earlier, for 2D system, we need 2 CBNs to establish coordinate
frame mapping. The algorithm will become significantly more robust and fault-tolerant if
we use more CBNs and compute the transformation matrix as the average of multiple CBNs
as opposed to just 2 of them. This should not degrade performance since we will most likely
have many CBNs established by the time the wave-front algorithm reaches the nodes that
48
Figure 3-15: Sweeping algorithm idea.
lie in both clusters.
3.6 Sweeping Algorithm
The algorithms presented above show several interesting ways of establishing localization
information in the Claytronics framework. The main drawback of these approaches, however,
is the fact that they all rely on the assumption that the initial configuration is a uniform
hexagonal lattice. While it is a reasonable assumption for a dozen or so catoms, having a
million catoms positioned in a perfect lattice formation is probably very unlikely. In this
algorithm we will drop this assumption, and instead assume that the catoms start in a
completely arbitrary configuration, e.g. many catoms randomly scattered on a table.
Now the challenge is not to assign positions and orientations to the catoms in the cluster,
but rather to absorb all the catoms into the cluster and establish localization during that
process.
3.6.1 Procedure
The exact procedure for creating a regular mesh of catoms from catoms that are randomly
scattered is a non-trivial process. However, the main idea behind it is rather simple and
is shown in Figure 3-15. We need to create a small base of catoms around the initial seed.
The base will act simply for physical support, while the ‘arm’ sweeps around the plane and
49
absorbs the catoms into the system. By absorbing we mean that when the arm hits a catom
while sweeping, the catom will roll down the arm to the base and become part of the system.
After the catom is absorbed, the arm will continue sweeping.
We realize that this conceptual idea can be implemented in many different ways – for
instance, one could build a tree that grows into the space absorbing catoms. An approach
based on rapidly expanding random trees [32] could be very applicable to this problem and
is presented in the next section.
Nevertheless, while we realize that there are many possibilities for the implementation,
we implemented this idea via a very simple algorithm. We start with a cluster of several
catoms. We selected one catom as a rolling catom. The rolling catoms rolls around the
cluster and looks for new connectivity with the nodes, i.e. determining whether it hit a
catom which is not part of the cluster. As soon as the rolling catom hits a newly discovered
catom, this new catom becomes the rolling catom and the old one stays in place.
The movement of the rolling catom is straightforward to compute. Assuming that the
rolling catom starts with magnet m connected to neighbor’s magnet n and there are k
magnets per catom, every time the catom wants to move it sets (m − 1) mod k magnet to
the polarity of m and turns m off. It also tells its neighbor to set the neighbor’s (n + 1)
mod k magnet to the polarity of n and turn n off as well. When a new neighbor is detected
via connectivity change, the rolling catom switches to the new catom and the process is
repeated.
This is a very simple algorithm, however it is sufficient to establish a connected mesh of
catoms assuming that the catoms are positioned with rather high density, i.e. less than one
catom away from each other.
3.6.2 Results
We ran this algorithm on the simulator in order to validate its performance and robustness.
The screenshots of this approach are shown in Figure 3-16. As we can see, this very sim-
ple approach does indeed suffice to establish a connected graph of catoms starting with a
completely arbitrary configuration. What is also interesting is that the algorithm appears
to be extremely robust to errors and misalignments. For example, the algorithm performs
50
Figure 3-16: Sweeping algorithm screen shots.
51
correctly even if the magnets sometimes misalign or mismatch. Furthermore, this approach
manages to build a lattice from a completely random configuration, demonstrating robust-
ness to positioning and orientation errors.
In terms of the running time, this simple algorithm is obviously slow and runs in O(n)
since only one catoms rolls around at the same time and only one catom can be absorbed
at any given time. However, we notice that this approach can expanded to work in the tree
fashion mentioned earlier. If the catoms are absorbed into the cluster by the tree, then the
performance will most likely become logarithmic due to tree branching. Thus for a tree with
k branches on average, the performance will become
runtime ≈ O(logk(n)) (3.13)
Thus we see that this approach can be made both robust as well as efficient. Further-
more, the fact that this algorithm can work with any initial configuration, makes it the best
candidate for the localization process in Claytronics.
3.7 Multi-Cluster Localization
As we have seen, localization using adjacency information is possible when the system stays
as one cluster. However, it gets more interesting when we have multiple clusters and need
to localize the clusters with respect to each other. The clusters are inherently disconnected
from each other, so we can no longer use adjacency information and thus other methods
must be employed. In this section we propose several ideas on how to deal with this issue.
3.7.1 RF Multi-Node Beacons
We notice that while we no longer have the adjacency information, we can still use RF RSSI
to determine how far we are from other clusters. We mentioned earlier that RSSI is rather
unreliable due to various issues and thus localization between two catoms is not feasible using
this method. However, instead of a pair of catoms and the estimated distance between them,
we now have two large clusters of catoms which have a whole matrix of distance estimates
52
x
Figure 3-17: RF multi-node beacon localization.
ABC
DE
FA
BC
DE
FA
BC
DEF
Figure 3-18: Messenger clusters.
AB
DC
DC
A BDC
A B
Figure 3-19: Physical bridge.
Figure 3-20: Rapidly expanding random trees.
53
as illustrated in Figure 3-17.
Various methods such as constraint optimizations [15] can be readily applied to solve this
matrix and determine the distance between the clusters as well as their relative orientation.
RSSI performance should be significantly better if the clusters are large and relatively far
apart.
3.7.2 Messenger Clusters
Another interesting idea is that we can use the cellular automata properties of the system
and create a single moving cluster called messenger. This cluster can be created from one of
the existing clusters by rearranging its catoms to form a new collection of catoms as shown in
Figure 3-18. The messenger can then move in a precise given direction since its locomotion
pattern is discrete – the messenger moves by repeatedly transferring its rear catoms to the
front. When the messenger reaches its destination neighboring cluster, it will confirm the
location by establishing a physical contact with the cluster. After that the messenger can
either be absorbed by the neighbor or return to its original cluster.
3.7.3 Physical Bridge
Another issue arises when we need to merge multiple clusters to form one large cluster – for
example, we need to construct a large new object from multiple objects in the scene are no
longer needed. In order to merge the clusters, their catoms need to form one object. We
propose that the two clusters form a physical bridge out of catoms and use that bridge to
transfer catoms from one cluster to another to merge the clusters as illustrated in Figure
3-19.
3.7.4 Rapidly Expanding Random Trees
The idea of the physical bridge can be expanded further to merge a large number of clusters
at once or to quickly find a neighboring cluster. We propose the use of rapidly expanding
random trees (RRTs) as a method of building these bridges [32]. RRTs have an ability
to quickly expand in only a few directions to explore places that are not yet visited. A
54
A
B
C
D
D’
A
B
C
D
Figure 3-21: Localization in 3D.
random walk suffers from a bias towards places already visited, whereas RRTs work in the
opposite manner by being inherently biased towards the places that are not yet visited. This
is achieved by applying the concept of Voronoi diagrams and ensuring that larger Voronoi
regions occur on the frontier of the tree.
RRTs are constructed by iteratively subdividing the Voronoi regions of the scene. They
are also proven to have good performance in terms of spreading and building such tree.
The performance should be even better if their propagation can be assisted by RSSI as a
heuristic. Figure 3-20 illustrates two clusters building RRT trees to find each other in a
complex environment.
3.8 3D Localization
The algorithms presented thus far are working in a 2D world. Extension to 3D presents
several difficulties as the number of position and angle variables increases. Nevertheless, the
same principles can be applied to 3D in order to perform similar localization techniques.
Determining positions of all catoms can be carried out similarly to the method outlined
in Section 4.4, except we will have to start with 4 seeds instead of 3. As shown in Figure
3-21, establishing positions of the catoms can be done in a similar fashion.
In terms of using RF RSSI, we actually believe that the performance will be significantly
better as each spherical layer of catoms will essentially form a 5cm thick RF shielding.
55
3.8.1 Single Seed
As we can see from the above picture, establishing position information in 3D can be carried
out in similar fashion. Instead of forming a hexagonal lattice, the catoms will now form a lat-
tice where each catom has potentially 12 contact points. Such a lattice can be approximated
by positioning the magnets on the catoms in a dodecahedron arrangement.
We start by selecting one node as a seed. The seed selects 3 other nodes that are adjacent
to each other as additional seeds and assigns them the proper 3D coordinates, with the
original node being at (0, 0, 0). The location information is strictly with respect to the local
coordinate system, however it will be consistent among all catoms in that coordinate frame.
This consistency is crucial in order to establish correct positions.
Now we have 4 nodes with assigned coordinates that will form the spanning vectors of
our 3D space. As shown in Figure 3-21, we can determine whether the node D should be
positioned at D or D′ based only on its adjacency information. By repeating this process
for all the nodes in the system, we can effectively compute the position of every node in the
lattice.
The steps taken by such an algorithm are demonstrated in Figure 3-22. The performance
is actually significantly better than its two-dimensional predecessor, since the algorithm can
propagate in 3 dimensions. Thus the speed of the algorithm is O ( 3√
n) where n is the number
of nodes, since the algorithm propagates in a spherical fashion assuming that the initial seed
is close to the center.
3.8.2 Distributed Algorithm
The speed of the previous algorithm can be greatly improved if we can start with multiple
nodes and perform the coordinate mapping technique presented earlier for the 2D case.
Each initial seed represents the origin of its cluster’s coordinate frame and all nodes in
the cluster are localized with respect to that coordinate frame. Thus the challenge is to
compute the mapping between the clusters and then apply this transformation to all the
nodes in the cluster.
In order to compute a transformation from cluster B to cluster A in 3D, we will need at
56
Figure 3-22: Steps taken by 3D localization algorithm with single seed.
57
Figure 3-23: Steps taken by 3D localization algorithm with multiple seeds.
least 3 nodes that are localized in both coordinate systems. The mapping from one cluster
to another can be established according to the following matrix:
AP = T × Rx × Ry × Rz × AB (3.14)
where T is the translation and R’s are the rotation components of the general transfor-
mation matrix.
The boundary nodes are responsible for communicating the localization information to
each other and computing the coordinate mapping. Once the mapping is computed, it is
broadcast to the entire cluster and the cluster is absorbed into the neighboring cluster.
Figure 3-23 demonstrates how this algorithm works. The algorithm starts with 3 separate
seeds, establishes 4-seed kernels for every cluster and eventually forms 3 clusters. Once the
clusters have Cluster Boundary Nodes, the clusters absorb each other to form larger clusters.
On average, each cluster will have 12 neighboring clusters. Thus if we start with k seeds
and have n nodes total, the performance of the algorithm will be log12k in terms of the time
it takes to merge all the clusters. In addition to that, it will take O(
3
√nk
)to localize the
nodes in each cluster, since per-cluster localization can be done in parallel. Thus we see
58
Figure 3-24: 3D sweeping algorithm screen shots.
that this method presents a very efficient way of establishing position information in the 3D
version of Claytronics.
3.9 3D Sweeping
The main problem of the above algorithms is that they rely on the assumption that the
catoms are arranged in a uniform 3D hexagonal lattice. While it is definitely possible to
arrange a small number of catoms in a uniform structure, having a large number of catoms
in such formation is extremely unlikely. Thus we will follow our 2D approach and build
the structure by absorbing catoms into it, rather than by trying to establish localization
information in a certain configuration.
The procedure of such an algorithm is similar to its 2D equivalent. We start with a small
number of catoms and one catom rolling around the structure. As soon as the rolling catom
hits a neighbor, the neighbor is absorbed into the cluster and is assigned the coordinates,
and the neighbor begins to perform the discovery.
Several screen shots of such cluster construction are shown in Figure 3-24. We see how
the catom rolls around the structure and absorbs one of the neighbors into the cluster.
59
A
B
Figure 3-25: Grain boundaries between clusters.
In terms of the running time, this simple version of sweeping has linear performance.
However, this algorithm can be extended to work in a tree-like fashion where each branch
will be absorbing new catoms in parallel with other branches. Since each branch can act
individually, the performance of such algorithm will be O (logkn) where k is the average
branching factor and n is the number of nodes.
3.10 Grain Boundaries
One of the issues that often arises in crystalline structures is grain boundaries. Crystals
usually form a highly regular lattice, but sometimes one of the crystals becomes misaligned
causing a whole section of the structure to have a different alignment. We will now present
an algorithm that can solve this issue in Claytronics.
The algorithm consists of two phases – computing cluster coordinates and merging the
clusters. There are two challenges here. The first one is to correctly compute cluster co-
ordinates, or in other words, to compute coordinates only for the nodes within the aligned
cluster. The second issue is to effectively merge these clusters.
3.10.1 Phase I
Figure 3-25 shows two clusters A and B that have an irregular boundary between them.
While the clusters do touch each other, they are misaligned.
The algorithm starts with 3 seeds or multiple 3-seed kernels similar to the most of the
algorithms presented so far. The algorithm computes coordinates for every catom that
60
Figure 3-26: Grain boundaries simulation.
has two adjacent neighbors localized in the same coordinate system. This adjacency is the
crucial requirement – it prevents localization from propagating from one coordinate system to
another coordinate system which is misaligned. As shown in Figure 3-25, the gray boundary
catoms will be given coordinates in both systems, but they will not propagate them from
one cluster to another. Thus the resulting configuration will have two clusters fully localized
without crossing the grain boundaries.
The simulation of this first pass of the algorithm is shown in Figure 3-26. As we can see,
localization even with multiple seeds, is contained within geometric clusters.
61
3.10.2 Phase II
The second pass of the algorithm computes the mappings between all clusters. We recall that
gray nodes in Figure 3-25 were localized or partially localized in both coordinate frames. The
difference between partial and full localization refers to the accuracy of the position estimate.
In partial localization the outmost node in one cluster detected a neighbor in another cluster,
but could not compute the exact position of the neighbor because it is the only node adjacent
to it. In the full localization, we have at least two nodes adjacent to the neighbor and thus
can precisely compute the position of the neighbor.
Thus the coordinates of the bordering node (CBN) in another coordinate system can be
either precise or have a small error. The error depends on the distance between the CBNs
establishing the transformation and the respective catom radius. The error of the x and
y of the transformation should be at most the catom radius. Assuming that the clusters
are large, i.e. significantly larger in size than the radius of the catom, the error rates for
establishing localization information of the entire structure should be small. If there are
multiple points of contact between the clusters, the error becomes even smaller, since the
average transformation T will be based on more data points.
Thus we can easily compute the transformation between any pair of clusters and thus
effectively merge them. Therefore this method will successfully establish localization infor-
mation in large formations of catoms that contain grainy crystalline boundaries.
3.11 Summary
We have developed various methods to localize the catoms in Claytronics. We have designed
algorithms that establish their positions and orientations in a variety of configurations. Sev-
eral of these approaches have been simulated and successfully proven to operate correctly in
the given system.
The localization techniques presented in this chapter are far from completion, just like
Claytronics is far from its final stages. Nevertheless, we have developed the initial localization
architecture, framework, hardware, and algorithms that can and will be readily used in the
current prototype version of Claytronics.
62
Chapter 4
Conclusion and Future Work
We have presented a detailed overview of the current status of localization in Claytronics.
The initial prototype framework was two-dimensional and macro-scaled. We chose to start
with this configuration, so that we could experiment with the system and obtain satisfactory
results before moving into more fine-grained 3D resolution. Most of the algorithms presented
in this thesis have been demonstrated to work in both 2D as well as 3D.
We implemented a powerful and versatile simulation framework to test the correctness
as well as performance of the algorithms that we have designed. The simulator is capable of
running a variety of loads with thousands of nodes at interactive frame rates.
All of the algorithms presented in this document have been tested on this simulator to
verify the correctness of their design and implementation. The performance and distributed
design of these algorithms seems promising for the large-scale structures of Claytronics.
While we have not tested the fully distributed 3D localization algorithms in the actual
physical system, we do not foresee any significant problems with it. We addressed many of the
potential issues including multi-cluster localization, variety of 3D configurations, misaligned
grain boundaries, and more.
63
Bibliography
[1] H. Abelson, D. Allen, D. Coore, C. Hanson, G. Homsy, T. F. Knight, R. Nagpal,
E. Rauch, G. J. Sussman, and R. Weiss. Amorphous computing. Commun. ACM,
43(5):74–82, 2000.
[2] G. Armitage. MPLS: The magic behind the myths. IEEE Communications Magazine,
2000.
[3] R. H. Arpaci-Dusseau, E. Anderson, N. Treuhaft, D. E. Culler, J. M. Hellerstein, D. Pat-
terson, and K. Yelick. Cluster i/o with river: Making the fast case common. In The
1999 Workshop on Input/Output in Parallel and Distributed Systems (IOPADS ’99),
Atlanta, Georgia, May 1999.
[4] P. Bahl and V. Padmanabhan. Radar: An in-building rf-based user location and tracking
system. In In Proceedings of IEEE INFOCOM, pages 775–784. IEEE, 2000.
[5] D. Baraff and A. Witkin. Physically based modeling. In Proceedings of SIGGRAPH
2002, Computer Graphics Proceedings, Annual Conference Series. ACM Press, 2002.
[6] B. N. Bershad, S. Savage, P. Pardyak, E. G. Sirer, M. Fiuczynski, D. Becker, S. Eggers,
and C. Chambers. Extensibility, safety and performance in the SPIN operating system.
In 15th Symposium on Operating Systems Principles, pages 267–284, Copper Mountain,
Colorado, 1995.
[7] A. D. Birrell and B. J. Nelson. Implementing remote procedure calls. In Proceedings of
the ninth ACM symposium on Operating systems principles, page 3. ACM Press, 1983.
64
[8] K. Bowers and G. Reshko. Routing in dynamic crystalline networks. In Project Report
15-712. Computer Science Department, Carnegie Mellon University, 2004.
[9] N. Bulusu, V. Bychkovskiy, D. Estrin, and J. Heidemann. Scalable, ad hoc deployable,
RF-based localization. In Proceedings of the Grace Hopper Celebration of Women in
Computing, Vancouver, British Columbia, Canada, October 2002. Institute for Women
and Technology.
[10] N. Bulusu, J. Heidemann, and D. Estrin. GPS-less low cost outdoor localization for very
small devices. In Technical report 00-729. Computer Science Department, University of
Southern California, 2000.
[11] J. Chapin, M. Rosenblum, S. Devine, T. Lahiri, D. Teodosiu, and A. Gupta. Hive: fault
containment for shared-memory multiprocessors. SIGOPS Oper. Syst. Rev., 29(5):12–
25, 1995.
[12] W. Cho and S.-L. Kim. A fully distributed routing algorithm for maximizing lifetime
of a wireless ad hoc network. In IEEE, pages 670–674, 2002.
[13] I. Clarke, O. Sandberg, B. Wiley, and T. W. Hong. Freenet: A distributed anonymous
information storage and retrieval system. Lecture Notes in Computer Science, 2009:46,
2001.
[14] D. E. Culler. Parallel Computer Architecture: A Hardware/Software Approach. Morgan
Kaufmann Publishers, 1998.
[15] L. Doherty, K. S. J. Pister, and L. E. Ghaoui. Convex position estimation in wireless
sensor networks. In IEEE Infocom, pages 1655–1663, 2001.
[16] Ember Corporation. EM2420 - fact sheet, 2004.
http://www.ember.com/products/family/spread-2420.html.
[17] Federal Communications Commission. Fcc wireless 911 requirements fact sheet, 2001.
http://www.fcc.gov/e911/.
65
[18] K. Gummadi, R. Gummadi, S. Gribble, S. Ratnasamy, S. Shenker, and I. Stoica. The
impact of dht routing geometry on resilience and proximity. In Proceedings of the
2003 conference on Applications, technologies, architectures, and protocols for computer
communications, pages 381–394. ACM Press, 2003.
[19] A. Harter and A. Hopper. A distributed location system for the active office. In IEEE,
pages 62–70, 1994.
[20] A. Harter, A. Hopper, P. Steggles, A. Ward, and P. Webster. The anatomy of a context-
aware application. In Proceedings of the 5th Annual ACM/IEEE International Confer-
ence on Mobile Computing and Networking, pages 59–68. ACM Press, 1999.
[21] J. Hightower and G. Borriello. Location systems for ubiquitous computing. Computer,
34(8):57–66, 2001.
[22] J. Hill, R. Szewczyk, A. Woo, S. Hollar, D. Culler, and K. Pister. System architecture
directions for networked sensors. In Proceedings of the ninth international conference on
Architectural support for programming languages and operating systems, pages 93–104.
ACM Press, 2000.
[23] Y.-C. Hu, A. Perrig, and D. B. Johnson. Rushing attacks and defense in wireless ad
hoc network routing protocols. In IEEE, pages 30–40, 2003.
[24] Chalermek Intanagonwiwat, Ramesh Govindan, and Deborah Estrin. Directed diffu-
sion: a scalable and robust communication paradigm for sensor networks. In Mobile
Computing and Networking, pages 56–67, 2000.
[25] R. Jantti and S.-L. Kim. Energy-efficient routing in DSSS ad hoc networks under mean
rate constraints. In IEEE, pages 428–432, 2003.
[26] D. B. Johnson, D. A. Maltz, and J. Broch. DSR: the dynamic source routing protocol
for multihop wireless ad hoc networks. pages 139–172, 2001.
[27] E. Jul, H. Levy, N. Hutchinson, and A. Black. Fine-grained mobility in the emerald
system. ACM Trans. Comput. Syst., 6(1):109–133, 1988.
66
[28] G. Ganger G. Gibson K. Amiri, D. Petrou. Dynamic function placement for data-
intensive cluster computing. In Usenix Annual Technical Conference, pages 307–322.
USENIX Association, 2000.
[29] M. F. Kaashoek, D. R. Engler, G. R. Ganger, M. Brice, R. Hunt, D. Mazi, T. Pinckney,
R. Grimm, J. Jannotti, and K. Mackenzie. Application performance and flexibility
on exokernel systems. In Proceedings of the sixteenth ACM symposium on Operating
systems principles, pages 52–65. ACM Press, 1997.
[30] B. Karp and H. T. Kung. GPSR: greedy perimeter stateless routing for wireless net-
works. In Proceedings of the 6th annual international conference on Mobile computing
and networking, pages 243–254. ACM Press, 2000.
[31] J. M. Khan, R. H. Kats, and K. S. J. Pister. Emerging challenges: Mobile networking
for smart dust. Journal of Communication and Networks, 2(3):188–196, 2000.
[32] S. LaValle. Rapidly-exploring random trees: A new tool for path planning. In Technical
Report TR 98-11. Computer Science Dept., Iowa State University.
[33] J. Li, C. Blake, D. S. J. De Couto, H. I. Lee, and R. Morris. Capacity of ad hoc wireless
networks. In Mobile Computing and Networking, pages 61–69, 2001.
[34] Linx Technologies. ES receiver module design guide, 2002.
http://www.rfdigital.com/pdf/rfd24124.pdf.
[35] Linx Technologies. ES transmitter module design guide, 2002.
http://www.rfdigital.com/pdf/rfd24125.pdf.
[36] A. B. McDonald and T. Znati. A mobility based framework for adaptive clustering in
wireless ad-hoc networks. IEEE Journal on Selected Areas in Communications, 17(8),
1999.
[37] Microchip Technology, Inc. PIC16F87X data sheet 28/40-pin 8-bit CMOS FLASH
microcontrollers, 2001.
http://www.microchip.com/download/lit/pline/picmicro/families/16f87x/30292c.pdf.
67
[38] Microsoft Research. Easy living, 2001.
http://www.research.microsoft.com/easyliving/.
[39] J.-P. Muller and M. Rodriguez. A distributed autonomous system architecture - appli-
cation to mobile robotics. IEEE, pages 25–34, 1993.
[40] R. Nagpal. Organizing a global coordinate system from local information on an amor-
phous computer. MIT Artificial Intelligence Laboratory, (1666), 1999.
[41] J. Newsome and D. Song. GEM: graph embedding for routing and data-centric storage in
sensor networks without geographic information. In Proceedings of the first international
conference on Embedded networked sensor systems, pages 76–88. ACM Press, 2003.
[42] D. Niculescu and B. Nath. Ad hoc positioning system (APS). In GLOBECOM, pages
2926–2931, 2001.
[43] R. J. Orr and G. D. Abowd. The smart floor: A mechanism for natural user identification
and tracking. In In Proceedings of the 2000 Conference on Human Factors in Computing
Systems, 2000.
[44] P. Papadimitratos and Z. J. Haas. Secure data transmission in mobile ad hoc networks.
In IEEE, pages 41–50, 2003.
[45] Vern Paxson. End-to-end routing behavior in the Internet. In Proceedings of the ACM
SIGCOMM Conference on Applications, Technologies, Architectures, and Protocols for
Computer Communications, volume 26,4 of ACM SIGCOMM Computer Communica-
tion Review, pages 25–38, New York, August 1996. ACM Press.
[46] L. L. Peterson and B. S. Davie. Computer networks: a systems approach. Morgan
Kaufmann Publishers Inc., 2000.
[47] N. B. Priyantha, H. Balakrishnan, E. Demaine, and S. Teller. Anchor-free distributed
localization in sensor networks. In Proceedings of the first international conference on
Embedded networked sensor systems, pages 340–341. ACM Press, 2003.
68
[48] N. B. Priyantha, A. Chakraborty, and H. Balakrishnan. The cricket location-support
system. In In Proceedings of MOBICOM 2000, pages 32–43. ACM Press, 2000.
[49] F. Raab, E. Blood, T. Steiner, and H. Jones. Magnetic position and orientation tracking
system. In IEEE, pages 709–717, 1979.
[50] A. Rao, C. Papadimitriou, S. Shenker, and I. Stoica. Geographic routing without loca-
tion information. In Proceedings of the 9th annual international conference on Mobile
computing and networking, pages 96–108. ACM Press, 2003.
[51] A. Reid, M. Flatt, L. Stoller, J. Lepreau, and E. Eide. Knit: Component composition
for systems software. In Proc. of the 4th Operating Systems Design and Implementation
(OSDI), pages 347–360, October 2000.
[52] Jerome H. Saltzer, David P. Reed, and David D. Clark. End-to-end arguments in system
design. ACM Transactions on Computer Systems, 2(4):277–288, November 1984.
[53] Stefan Savage, Andy Collins, Eric Hoffman, John Snell, and Thomas E. Anderson.
The end-to-end effects of internet path selection. In Proceedings of SIGCOMM, pages
289–299, Boston, MA, August-September 1999.
[54] C. Savarese, J. M. Rabaey, and K. Langendoen. Robust positioning algorithms for
distributed ad-hoc wireless sensor networks. In Proceedings of the General Track: 2002
USENIX Annual Technical Conference, pages 317–327. USENIX Association, 2002.
[55] A. Savvides, C.-C. Han, and M. B. Strivastava. Dynamic fine-grained localization in
ad-hoc networks of sensors. In Proceedings of the 7th annual international conference
on Mobile computing and networking, pages 166–179. ACM Press, 2001.
[56] Y. Shang, W. Ruml, Y. Zhang, and M. P. J. Fromherz. Localization from mere con-
nectivity. In Proceedings of the 4th ACM international symposium on Mobile ad hoc
networking & computing, pages 201–212. ACM Press, 2003.
[57] I. Stoica, D. Adkins, S. Zhuang, S. Shenker, and S. Surana. Internet indirection infras-
tructure. In Proceedings of SIGCOMM, pages 73–88, August 2002.
69
[58] I. Stoica, R. Morris, D. Karger, M. F. Kaashoek, and H. Balakrishnan. Chord: A
scalable peer-to-peer lookup service for internet applications. In Proceedings of the
2001 conference on applications, technologies, architectures, and protocols for computer
communications, pages 149–160. ACM Press, 2001.
[59] T. von Eicken, D. E. Culler, S. C. Goldstein, and K. E. Schauser. Active messages: a
mechanism for integrating communication and computation. In 25 years of the interna-
tional symposia on Computer architecture (selected papers), pages 430–440. ACM Press,
1998.
[60] A. Watt. 3D Computer Graphics. Addison-Wesley, 2000.
[61] M. Yim, Y. Zhang, J. Lamping, and E. Mao. Distributed control for 3d metamorphosis.
Autonomous Robots, 10(1):41–56, 2001.
[62] Y. Zhang, K. D. Roufas, and M. Yim. Software architecture for modular self-
reconfigurable robots. IEEE, pages 70–85, 2001.
[63] D. Zorin and P. Schroder. Subdivision for modeling and animation. In Proceedings of
SIGGRAPH 2000, Computer Graphics Proceedings, Annual Conference Series. ACM
Press, 2000.
70