Just as a proof-of-concept, here’s a barcode scanner written in six lines of Python code:
import android
droid = android.Android()
code = droid.scanBarcode()
isbn = int(code['result']['SCAN_RESULT'])
url = “http://books.google.com?q=%d” % isbn
droid.startActivity(’android.intent.action.VIEW’, url)
Thanks to fellow Googler Vijayakrishna Griddaluru for sending me this sample code. Visiting the resulting url offers the option to add that book to your library:
Pretty easy, huh? You can read all about the new scripting environment. Not only can you scan bar codes, you can use text-to-speech, make phone calls, send text messages, read sensor data, and find your location--all from easy scripts. One person wrote a script to go into silent mode when the phone is placed screen-down on the table. It took less than 20 lines of code, and that’s including comments!
The Android Scripting Environment should make fun projects even easier. Brad Fitzpatrick wrote about using his Android phone to open his garage door automatically when his motorcycle gets close to home. Now those sorts of projects are even easier to write.
Last year I suggested potential Summer of Code projects and one of my favorite suggestions was “How about a good open-source program to manage your book library? Something like the Delicious Library program, but that works with Linux?” In the blog comments, Colin Colehour left an excellent comment: “Matt, Can’t you use Google Books to keep track of your book library at home? You can add books that you own to the ‘my library’ list and then export that as an xml file and they have RSS feeds.”
The suggestion was so obvious that I smacked my head. Why install software at all when a website will store the data for you? The only problem was how to tell Google which books I own. Well, there’s a neat hack for this too: Amazon carries the Adesso NuScan 1000 bar code scanner for $65.44 with free shipping. I’m sure you can get barcode scanners for cheaper (anyone remember the CueCat scanner that was free?), but the Adesso had good reviews.
With that, adding your books to Google’s My Library feature is simplicity itself--the Google Books team has tweaked the workflow so that you can barcode scan and add lots of books very quickly. Here’s the video to demonstrate:
Why would you record which books you own in the first place? The immediate reason is that you can run full-text searches against the books in your library. That’s right: just by scanning bar codes, you can search over the text of books you own. Down the road, I can easily imagine other uses. Wouldn’t it be great if you could upload your list of books to Amazon, and it would automatically suggest other books you should read? Or avoid suggesting books that you already own? Josh Lowensohn mentions another great reason to do this: it creates a record for insurance purposes.
Once you have your book list, there are social networks for book lovers such as Goodreads and LibraryThing. And please note: this isn’t the only way to scan your books. Delicious Library 2 is $40 commercial software for the Mac that can use your Mac’s built-in webcam.
Special thanks to Michael ‘Wysz’ Wyszomierski for recording and producing this video. I love that he showed the computer’s screen and showed an “action shot” of scanning the books.
I should be back over at mattcutts.com. I’m sure some bits have sloshed around in the transition from dullest.com to mattcutts.com--let me know if you see anything truly weird.
I plan to talk sometime soon about what I learned in the process of moving to a completely different domain for a month.
In this post you’ll learn how to make a working Bluetooth weight sensor + fast real-time graphical display with about 200 lines of Python code. You can code any Nintendo Wii-like video game for Ubuntu/Linux and the Nintendo Balance Board very easily. Here’s a video demonstration:
You must also install the development package for BlueZ, which is the official Linux Bluetooth protocol stack:
sudo apt-get install libbluetooth-dev
Make a directory to hold your code:
mkdir ~/wiibalance
cd ~/wiibalance
Check out the CWiid (get it? CWiid? Seaweed?) library using Subversion:
svn co http://abstrakraft.org/cwiid/svn/
When I checked CWiid out, it was up to version 183.
Compile the library, e.g.
cd ~/wiibalance/svn/trunk
autoconf ./configure --libdir=/usr/lib (according to this page, you need the libdir parameter on Ubuntu)
make
sudo make install
Now apply the patch to CWiid to add the Balance board. Go to http://abstrakraft.org/cwiid/ticket/63, click on balance.diff, then at the bottom of the resulting page, click on “Original Format” to download the diff as a raw text file. Do the same to download the “weighdemo.py” file. Now apply the balance.diff patch:
patch --dry-run -b -p0 < balance.diff(this command tests that everything would apply without errors)
patch -b -p0 < balance.diff
Finally, compile the code and install it:
make
sudo make install
Then you can play with the weighdemo.py script. You’ll want to change the line “sys.path.insert(0, ‘/home/tbble/code/cwiid/svn/cwiid/python/build/lib.linux-x86
_64-2.5/’)” to point to the right place on your system, e.g. /home/youraccountname/wiibalance/svn/trunk/python/build/lib.linux-i686-2.5/ . And you may need to disable the “if wiimote.state['ext_type'] != cwiid.EXT_BALANCE” if statement. I also added a few lines to print out the values and calibration numbers for the four sensors. Here’s what I get when I run my program:
$ ./weighdemo.py
Put Wiimote in discoverable mode now (press 1+2)…
Type q to quit, or anything else to report your weight
right_top 2249 [2293, 4004, 5725]
right_bottom 1467 [1449, 3155, 4874]
left_top 12471 [12476, 14238, 16015]
left_bottom 6822 [6848, 8581, 10325]
-0.58kg
Type q to quit, or anything else to report your weight
In this run, the first example is weighing with nothing on the scale. The second example is with me standing on the scale.
Here’s what you need to know. First, absorb this info from the Wikipedia entry:
Although the Japanese packaging states that it is designed to support people weighing up to 136 kilograms (300 pounds) and the “Western” Balance Board up to 150 kg (330 pounds), they are actually the same board. The packaging differs due to laws in Japan and other nations regarding weights and measures. While the board only displays weight readings up to what is printed on the packaging, the actual physical structure of the board can withstand much greater force equivalent to around 300 kg (660 pounds).
Okay, so the Wii Balance Board is certified for 300 pounds (136 kg) in Japan and 330 pounds (150 kg) in the U.S. The Wii Balance Board has four sensors, so each sensor is certified for up to 136 kg / 4 = 34 kg per sensor in Japan or 150 kg / 4 = 37.5kg per sensor in the United States. Now that you’ve been schooled on that, the following Wii Balance Board calibration information from WiiBrew will make more sense.
Each sensor returns 2 bytes of data and also has six bytes of calibration data. Think of it as a 16 bit number and three calibration numbers, that are also 16 bits apiece. The three calibration numbers correspond to the sensor reading for 0 kg, 17 kg, and 34 kg (those numbers should look familiar if you look at the previous paragraph). So if sensor #1 gives a value of 5725 and the 34 kg number is also 5725, then that sensor is reporting exactly 34 kg of weight on it.
The WiiBrew page says “Calculating the weight on each sensor simply involves interpolating between the two calibration values your reading falls between (or using the higher two values if your reading exceeds the highest calibration value), and the total weight on the board is the sum of these [four sensor] values.”
With that info, let’s go back to one of my sensor readings and convert it to actual kg. Take the reading “right_top 3618 [2293, 4004, 5725]“. The sensor value is 3618, which is between the 0 kg calibration number of 2293 and the 17 kg calibration number of 4004. So the weight on the right_top sensor is 17kg * (3618-2293)/(4004-2293) or 17kg * 0.7744 or 13.2 kg. I tend to put my weight on the back of my feet, which is why 13.2 kg is a little lower than my total weight (82 kg) divided by the four sensors, which would be 20.5 kg per sensor.
If your eyes haven’t completely glazed over, the upshot is that the Balance Board has four independent weight sensors, each calibrated to kilograms, and you can read those sensors in real-time over Bluetooth. Translating the sensor values into weight only takes four lines of Python code. From there, you can do anything you want with that data. Play a game, hook your Wii Balance Board up to Google Earth, or you can even automatically upload your weight to a Google Spreadsheet.
For example, you can run the command “sudo apt-get install python-pygame” to install pygame. Then go back to this page and download the scalesgui.py and system.ini files as you did before (click on them, then click on “Original Format” at the bottom of the resulting page). Make scalesgui.py executable with “chmod a+x scalesgui.py” and comment out the “EXT_BALANCE” if statement, then run “./scalesgui.py” and this is what you’ll see:
This is a snapshot, but the program runs just as fast as any video game. You can lean and move the circle around really fast. And in the bottom right, you can see that I weigh 81.74 kg, which is about 180 pounds.
I know this is a long post, but the upshot is that with 10-15 minutes of work, you can use a Wii Balance Board as a real-time sensor with Linux. I hope you have fun!
