Ubiquitous Computing

You are currently browsing articles tagged Ubiquitous Computing.

Little Robots — Hardware

January 19, 2010 in Projects | 12 comments

This is part one of a three part series: Part two covers the firmware, and part three will cover the software.

I find interaction design to be pretty fascinating. And lets face it, most of the technology we deal with on a daily basis has not been designed with interaction in mind. Or at least not subtle interaction.

Take telephones: they’re a priority interrupt. When a phone rings, you go through a full context switch. You have to stop what you’re doing to answer. Email doesn’t interrupt, but it’s not priority either. Email doesn’t say “I’m thinking of you” it says “I thought of you twenty minutes ago”. These are great examples of technologies that meet their minimum need; they do work, but do they work well? Is email the best way to get text from one human being to another? My spam filter says no. Is the telephone the best way to tell someone you were just thinking about them?

When you’re in a room with someone, there are many different subtle ways to indicate that you enjoy their presence. Everything from where you sit to how you breath has at least some degree of significance — some degree of communication. This project was my way of performing that communicative act, when I’m not in a room with that someone.

Enough waxing philosophical: I made two little robots. One for my fiancé’s desk, and one for mine. When you poke one in the belly, the other one waves.

Without further ado, here’s part one:

Hardware

The hardware on this project is absolutely informed by the firmware. From the outset I expected to use Objective Development’s V-USB package. It provides a software USB stack capable of running on 8-bit Atmel AVR microcontrollers.

With that in mind, I sought a challenge and picked the smallest AVR I could get on short notice — the ATtiny85, in an 8-pin DIP package. This is a pretty powerful chip, at least for these purposes. Less than $3 Canadian gets 8kB of flash program storage, a half a kilobyte of RAM, two hardware timers, and an internal oscillator.

Not really being one to reinvent the wheel, I found an existing project using the same firmware and microcontroller — the one key keyboard by Flip van den Berg. After some ethical deliberations, I shamelessly took his schematic, and breadboarded out myself:

Prototype USB Layout

To my surprise, it actually ran! You can make a USB keyboard on a breadboard! And it works on any computer that supports HID compliant devices!

The next step was to take the same circuit, and put it on something a little bit more permanent. In this case, some protoboard. The circuit on the left is a programming target board, with a standard programming header. I use it with an Adafruit USBtinyISP programmer. The circuit on the right is the USB controller with a button and header for a servo motor.

Servos are fairly useful beasts. They don’t really need drivers. Supply them with a suitable PWM signal, and they’ll drive themselves. In this case, the servo is powered off the +5v USB supply, even though the microcontroller is running at +3.3v. My servo didn’t seem to care, and quick google searching suggests that this is pretty standard; servos will amplify their PWM signal internally.

ATtiny85 target board and USB test board.

So at this point I found that the electronics basically worked. I was able to control a servo, and read button presses. So now for some larger scale hardware.

I don’t have access to a full shop, so I relied on a low impact sculpting material: Sculpey, a polymer clay, similar to Fimo. A little armature wire, some low-fidelity sculpting and the parts went into the oven at 250° F for about 15 minutes. As easy as sculpey is to work, it is even easy to rework. Hot glue and acrylic paint stick to it quite happily.

Little Robot Parts

Next, I installed the guts with lots of hot glue.

Little Robot Guts

Then I painted the exterior with acrylic spray paint. I touched up the eyes with acrylic paint, and added craft foam tank treads and covers for the belly-switches.

Little Robots

And here’s what they look like from the back.

Little Robot Innards

Next up: The firmware!

Update: This article was featured on Make: Online.

Tags: , , , ,

Little Robot Preview.

January 11, 2010 in Projects | No comments

Little Robots

For our wedding save-the-date cards, I drew two little robots.

For Christmas, I made little robots for Sheena.

Little Robots

They’re USB powered — one for her desk and one for mine. When you poke one, the other will wave, wherever they happen to be.

These are powered by an ATtiny85, Objective Development’s V-USB and python.

More details to come soon.

Tags: , , , ,

Sketching In Hardware (2)

January 5, 2010 in Projects | 2 comments

I’ve had an urge lately to post some of the nifty projects I’ve done over the last few months. Hopefully it will help me put some of my experiences in context. Not to mention actually taking notes lets me find them later.

As long as computers have existed, we’ve tried to represent the physical world in the virtual one.  This trend goes as far back as the punched cards and tabulating machines used in the 1890 United States Census, but it doesn’t end there.  When computers became common enough that regular people — without specialized training — may use them, interface designers went straight for spacial metaphors.  We pulled more of the physical world into the machine.

What I find fascinating about hardware hacking and platforms like the Arduino is that we can reverse that trend.  We can interact with computers through the physical world, rather than interpreting the physical world through a virtual one.  And we can do it trivially.

Here’s my own humble first effort:

This is a bot that monitors an IRC channel. When I announce a mood, it moves the needle accordingly. It’s not very complicated at all — some cardboard, marker, sticky tape, a ~$10 hobby servo, and two pieces of code.

The first, runs on a host computer, monitors the IRC channel, and tells the arduino where to point the needle. Ruby is very terse — but it’s also very expressive. It is easy to make very functional object oriented programs in very little space.

#!/usr/bin/env ruby
 
require 'rubygems'
require 'net/irc'
require 'serialport'
 
# This is an IRC Bot that also
# talks to an arduino microcontroller.
class ToneOMeter < Net::IRC::Client
  # What emotions should this bot respond to?
  # These are passed directly to the arduino.
  @@emotions = {
    'sarcastic' => '20s',
    'sardonic' => '60s',
    'acerbic' => '135s',
    'cynical' => '180s'
  }
 
  def self.emotions
    @@emotions
  end
 
  def initialize(*args)
    super
 
    # Connect to the arduino.  This will work on linux, other
    # platforms may require some adjustment.
    @sp = SerialPort.new "/dev/ttyUSB0", 19200
  end
 
  def on_rpl_welcome(m)
    # We've connected to the server, join a channel.
    post JOIN, "#tone-o-test"
  end
 
  def on_privmsg(m)
    # Someone has entered text into the channel.  Who was it?
    name = /^(.+)!/.match( m.prefix )[1]
 
    # If it was my owner (tony), and it's an action...
    if name =~ /tony/ && m[1] =~ /ACTION/
      # Extract the action, and send the canned result to the arduino.
      action = /\01ACTION is (.+)\01/.match( m[1] )[1].strip.downcase
      @sp.write( ToneOMeter.emotions[ action ] )
    end
  end
end
 
# Instantiate a new bot, and start it.
ToneOMeter.new("test.server", "6667", {
        :nick => "Tone-O-Meter",
        :user => "Tone-O-Meter",
        :real => "Tone-O-Meter",
}).start

The second set of software is taken from the Arduino Playground and runs on the microcontroller itself. It uses Arduino’s servo library to set the servo to a given angle. This isn’t my code, but it’s trivial enough (and useful enough) to repeat here.

#include 
 
Servo servo1;
 
void setup() {
  pinMode(1,OUTPUT);
  servo1.attach(14); //analog pin 0
  //servo1.setMaximumPulse(2000);
  //servo1.setMinimumPulse(700);
 
  Serial.begin(19200);
  Serial.println("Ready");
}
 
void loop() {
  static int v = 0;
 
  if ( Serial.available() ) {
    char ch = Serial.read();
 
    switch(ch) {
      case '0'...'9':
        v = v * 10 + ch - '0';
        break;
      case 's':
        servo1.write(v);
        v = 0;
        break;
     }
  }
  Servo::refresh();
}

So there you have it: Physical computing done with little electronics skill, for less than $40, and in less than a hundred lines of code. This is a pretty trivial example, but even just given the context of IRC it suggests some nifty projects. For example, a physical representation of how many users are in a channel? Or how active the conversation is?

With physical interfaces now trivial to prototype, interface designers have yet another tool: Physical, tangible interfaces.

Update: This article was featured on Make: Online.

Tags: , , ,

On Interfaces.

March 16, 2009 in Linkage | No comments

World Builder

Bruce Branit



Microsoft Office Labs Vision 2019

Tags: , , ,

On locative services.

February 21, 2009 in Linkage | 1 comment

Exporting the past into the future:

Focusing on (a) nothing more granular than cities-as-place and days-as-time and (b) broadcasting future intention, we could find a valuable location-based service for a certain audience – surfacing coincidence for frequent travelers.

…

Point (b) though, still has me thinking that sharing your precise whereabouts – where you are right now, has limited value.

(via Short Sharp Science, via Nora3000)

Tags: , , ,

On ubiquitous computing.

April 13, 2008 in Linkage | No comments

Bruce Sterling on mobile devices and geolocation.

His list of devices that have been subsumed into mobile phones is pretty astonishing.

Tags: , , ,