Wireless Technologies / Protocols

• WiFi (802.11)
• XBee/ZigBee (802.15.4)
• BlueTooth (802.15.1)
• RFID
• Near Field Communication (Two-Way RFID)

These are four of the principal wireless technologies in mainstream use today.  The goal is to determine within some degree of accuracy the position in 2 or 3 dimensions of a wireless node.  Most, if not all, of the available approaches utilize the RSSI (Received Signal Strength Indicator) of the target node’s connections to nearby nodes.

If you have fixed routers with known locations, you can use the RSSI values of their connections to the target node to calculate the distances from the fixed nodes to the target node.  However, any RSSI value will be heavily influenced by a number of factors that may be out of your control: interfering structures, interfering people (we are walking bags of water, which readily absorbs 2.4ghz radiation) and other interfering radio signals or noise.

Due to these issues, some smart folks developed a system called RADAR that uses ‘location fingerprinting’ to take a bunch of readings of signal strengths under varying conditions and associate them with known locations.  There are a variety of algorithms to tabulate this information, one of which uses neural networks.

Here is a collection of extremely useful papers and links that describe these various approaches, techniques and technologies:

Resources

• Survey of Wireless Indoor Positioning Systems [pdf]
• Indoor Location using 802.15.4
• Bluetooth Triangulation [pdf]
• CS/RADAR: Indoor Location Discovery and Tracking [pdf]
• Indoor location tracking using RSSI readings from a single Wi-Fi access point [pdf]
• Location Estimation in ZigBee Network Based on Fingerprinting [pdf]
• Experimental Analysis of RSSI-based Location Estimation in Wireless Sensor Networks [pdf]
• Position Location Monitoring Using 802.15.4/ZigBee technology [pdf]

Hardware

Simple! Here’s all you need:

• An XBee breakout board (so you can plug it into your breadboard)
• An XBee Explorer (not necessary with ad-hoc mode, but I had one around so this tutorial will use it)
• 3.3V regulator (ONLY—the module has a 10% tolerance, so anything beyond that will either not work or damage the module).
• 10µF and 0.1µF capacitors for good measure (clean power is especially important when using radio devices)
• Power and Ground (Pins 1 and 10, the top and bottom pins on the left side of the module)
• An LED connected to pin 9.  In practice you’d want to put a current-limiting resistor on it, i.e. 220 ohms, but for a quick test it won’t matter.  The module only drives 8mA on this pin.
• That’s it!

set wlan phrase <your wpa password>
set wlan ssid <your ssid>
save
reboot

ftp u

telnet <module's ip address> 2000

set sys mask 0x21f2

set sys output 2 2

set sys output 0 2

References

• RN-XV User Manual (API reference, etc.)
• RN-XV Datasheet (pinout and electrical characteristics)

1. Install Eclipse.  I had the “Galileo” version which I found out the hard way isn’t supported, so I downloaded the newest as of writing (“Indigo”).
2. Install the Android SDK.
3. Install the Android Developer Tools (ADT) plugin for Eclipse.
4. Download the WiMM Android Add-On (make a free developer account first to get it).
5. Put the WiMM Add-On folder in the add-ons folder in the Android SDK.
6. Run the Android SDK Manager from Eclipse > Window.
7. Select and install Android 2.1 (API 7) and the Android SDK Platform Tools.
8. Make a WiMM Android Virtual Device with SD card 2 GiB and resolution 160×160.
9. You can now make new projects that target the WiMM One Add-On.

Building and Running on the Emulator

1. Open a terminal at [your-android-sdk]/add-ons/addon_wimm_one_7/tools and run ./emu.
2. Wait for the emulator to boot up (it takes a minute).
3. Hit “Run” in Eclipse.
1. If you get an expired certificate error, look here.
4. If you’re prompted to choose a device, choose the emulator.

Building and Running on the Device

1. On your WiMM, go to Settings > Advanced and turn on “Allow USB debugging”
2. Plug in your WiMM.
3. Open a terminal at addon_wimm_one_7/tools and run ./android update adb.
4. Go to addon_wimm_one_7/platform-tools and run ./adb kill-server and ./adb start-server.
5. Now run ./adb devices and you should see your hardware device listed as well as any running emulators.
6. Now when you run your app from Eclipse, you can choose your hardware device!

Tonight I whipped up a little test of the module to get a joystick to talk to a Node.js server over WiFi.  I attached +3V power and ground to the module (pins 1 and 10, respectively), pin 2 (TX) to Arduino digital pin 0 (RX), and pin 1 (RX) to Arduino digital pin 1 (TX).  That’s all the hardware setup you need.

I used this WiFly library to handle the connection.  All it does is talk to the WiFly module over serial and send control commands, so the library abstracts that a bit.  Here’s the Arduino sketch I built:

#include "WiFly.h"

#define PIN_VERT      0  // analog
#define PIN_HOR       1  // analog

#define PIN_PUSH      2
#define PIN_LED_RED   3
#define PIN_LED_GRN   4

int vert = 0;
int hor = 0;
bool push;

char* ssid = "yourNetwork";
char* pass = "yourPassword";

char* serverAddress = "yourServer";
int serverPort = 1337;

Client client(serverAddress, serverPort);

void setup(){
  pinMode(PIN_PUSH, INPUT);
  pinMode(PIN_LED_RED, OUTPUT);
  pinMode(PIN_LED_GRN, OUTPUT);

  digitalWrite(PIN_PUSH, HIGH);    // set pull-up resistor
  digitalWrite(PIN_LED_RED, LOW);  // start off
  digitalWrite(PIN_LED_GRN, LOW);

  Serial.begin(9600);
  WiFly.setUart(&Serial);
  WiFly.begin();

  if (!WiFly.join(ssid, pass, true)) {
    digitalWrite(PIN_LED_RED, HIGH);
    while (1) {
      // Hang on failure.
    }
  }

  digitalWrite(PIN_LED_GRN, HIGH);

  if (client.connect()) {
    client.println("ohai!");
    client.println();
  } else {
    // do nothing
  }
}

void loop(){
  vert = analogRead(PIN_VERT);
  hor = analogRead(PIN_HOR);
  push = digitalRead(PIN_PUSH);

  digitalWrite(PIN_LED_RED, !push);

  client.print(vert);
  client.print('\t');
  client.print(hor);
  client.print('\t');
  client.print(push);
  client.println();
  delay(10);
}

And here’s the very basic Node.js server that just prints out the values it receives:

var net = require('net');

var server = net.createServer(function(socket) { //'connection' listener
	console.log('server connected');

	socket.setEncoding('ascii');

	socket.on('end', function() {
		console.log('server disconnected');
	});

	socket.on('data', function(data){
		console.log(data);
	});
});

server.listen(1337, function() { //'listening' listener
	console.log('server bound');
});

Here’s an example script that adds a URL from an argument with auto_managed turned off:

#!/usr/bin/env python
# encoding: utf-8
"""
DelugeEasyAdd

Starts a new Deluge torrent from a URL.

Created by Ted Hayes.

"""

import urllib, os, sys, re
# Import the client module
from deluge.ui.client import client
# Import the reactor module from Twisted - this is for our mainloop
from twisted.internet import reactor

# Set up the logger to print out errors
from deluge.log import setupLogger
setupLogger()

# Connect to a daemon running on the localhost
# We get a Deferred object from this method and we use this to know if and when
# the connection succeeded or failed.
d = client.connect()

PRIO_NORMAL = 1
PRIO_MAX = 5

torrentURL = sys.argv[1]
# btjunkie URLs use 'download.torrent' as the filename, get a better one
if re.search("btjunkie", torrentURL):
    filename = re.findall("torrent\/(.*?)\/", torrentURL)[0]
else:
    filename = os.path.basename(torrentURL)

print "Using filename: %s" % filename

def addTorrent():
    client.core.add_torrent_url(torrentURL, '/home/daleth/Downloads/'+filename, {'auto_managed':False}).addCallback(added)

def added(s):
    print "Added status: ",s
    #client.core.resume_torrent()
    disconnect()

# We create a callback function to be called upon a successful connection
def on_connect_success(result):
    print "Connection was successful!"
    addTorrent()

def disconnect():
    print "disconnecting"
    client.disconnect()
    reactor.stop()

# We add the callback to the Deferred object we got from connect()
d.addCallback(on_connect_success)

# We create another callback function to be called when an error is encountered
def on_connect_fail(result):
    print "Connection failed!"
    print "result:", result

# We add the callback (in this case it's an errback, for error)
d.addErrback(on_connect_fail)

# Run the twisted main loop to make everything go
reactor.run()

I still have to figure out how to then automatically resume the torrent.

Here are some helpful links:

UIClient Documentation

UIClient Example 

I was doing this on my Ubuntu 10.04 Linode instance, and we were targetting ARM processors, so first I had to install the appropriate gcc toolchain.  I didn’t have add-apt-repository, so I had to install python-software properties first.  The last install is to get libc (stdio, etc).

sudo apt-get install python-software-properties
sudo add-apt-repository ppa:linaro-maintainers/toolchain
sudo apt-get install gcc-4.5-arm-linux-gnueabi
sudo apt-get install libc6-armel-cross libc6-dev-armel-cross

Then I used these commands for compiling, disassembling and looking for interesting strings:

arm-linux-gnueabi-gcc-4.5 -O3 -c helloWorld.c
arm-linux-gnueabi-objdump -D helloWorld.o | less
strings -t x helloWorld.o

Package variant PTH1 in the old version of device set RESISTOR is not present in the new version of this device set.

This is caused by a library in the original schematic having some different package definition than the library in the new schematic.  The fix is easy: In the original schematic, go to Library > Update All.  Then you can copy and paste without the error!

Serial.println('test');

And getting a series of numbers like 25536 instead of the expected text. It turned out the problem was just the use of the ‘ instead of a “. Sigh.