roomba 0.0.1

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,5 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 Doug P.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,21 @@
+= roomba
+
+Library to control a Roomba.
+
+This code wraps the library found here:
+  http://roombahacking.com/roombahacks/roombacmd/
+
+== Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Make your feature addition or bug fix.
+* Add tests for it. This is important so I don't break it in a
+  future version unintentionally.
+* Commit, do not mess with rakefile, version, or history.
+  (if you want to have your own version, that is fine but
+   bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request. Bonus points for topic branches.
+
+== Copyright
+
+Copyright (c) 2010 Doug P. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,48 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    gem.name = "roomba"
+    gem.summary = %Q{Library to control a Roomba}
+    gem.description = %Q{Library to control a Roomba}
+    gem.email = "dougtko@gmail.com"
+    gem.homepage = "http://github.com/dougsko/roomba"
+    gem.authors = ["Doug P."]
+    gem.add_development_dependency "rspec"
+    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+Spec::Rake::SpecTask.new(:rcov) do |spec|
+  spec.libs << 'lib' << 'spec'
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :spec => :check_dependencies
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "roomba #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb', 'ext/**/*.c')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/ext/extconf.rb

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+#
+#
+#
+require 'mkmf'
+
+create_makefile("roomba")

data/ext/roomba.c

@@ -0,0 +1,325 @@
+#include "ruby.h"
+#include "roombalib.h"
+
+static VALUE cRoomba;
+
+static void 
+roomba_destroy(Roomba *roomba)
+{
+        roomba_free(roomba);
+}
+
+static VALUE 
+roomba_new(VALUE klass, VALUE rb_portname)
+{
+    const char *portname;
+    struct Roomba *roomba;
+
+    portname = STR2CSTR(rb_portname);
+    roomba = roomba_init(portname);
+    return Data_Wrap_Struct(klass, 0, roomba_destroy, roomba);
+}
+
+static VALUE 
+close(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_close(roomba);
+    return Qnil;
+}
+
+static VALUE 
+valid(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    return INT2NUM(roomba_valid(roomba));
+}
+
+static VALUE get_portpath(VALUE self){
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    return rb_str_new2(roomba_get_portpath(roomba));
+}
+
+static VALUE 
+send(VALUE self, VALUE rb_cmd, VALUE rb_len)
+{
+    struct Roomba *roomba;
+    const uint8_t *cmd;
+    int len;
+
+    cmd = STR2CSTR(rb_cmd);
+    len = NUM2INT(rb_len);
+    Data_Get_Struct(self, struct Roomba, roomba);
+
+    return INT2NUM(roomba_send(roomba, cmd, len));
+}
+
+static VALUE 
+drive(VALUE self, VALUE rb_vel, VALUE rb_rad)
+{
+    struct Roomba *roomba;
+    int vel, rad;
+
+    vel = NUM2INT(rb_vel);
+    rad = NUM2INT(rb_rad);
+    Data_Get_Struct(self, struct Roomba, roomba);
+
+    roomba_drive(roomba, vel, rad);
+    return Qnil;
+}
+
+static VALUE 
+stop(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_stop(roomba);
+    return Qnil;
+}
+
+static VALUE 
+forward(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_forward(roomba);
+    return Qnil;
+}
+
+static VALUE 
+forward_at(VALUE self, VALUE rb_vel)
+{
+    struct Roomba *roomba;
+    int vel;
+
+    vel = NUM2INT(rb_vel);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_forward_at(roomba, vel);
+    return Qnil;
+}
+
+static VALUE 
+backward(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_backward(roomba);
+    return Qnil;
+}
+
+static VALUE 
+backward_at(VALUE self, VALUE rb_vel)
+{
+    struct Roomba *roomba;
+    int vel;
+
+    vel = NUM2INT(rb_vel);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_backward_at(roomba, vel);
+    return Qnil;
+}
+
+static VALUE 
+spinleft(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_spinleft(roomba);
+    return Qnil;
+}
+
+static VALUE 
+spinleft_at(VALUE self, VALUE rb_vel)
+{
+    struct Roomba *roomba;
+    int vel;
+
+    vel = NUM2INT(rb_vel);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_spinleft_at(roomba, vel);
+    return Qnil;
+}
+
+static VALUE 
+spinright(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_spinright(roomba);
+    return Qnil;
+}
+
+static VALUE 
+spinright_at(VALUE self, VALUE rb_vel)
+{
+    struct Roomba *roomba;
+    int vel;
+
+    vel = NUM2INT(rb_vel);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_spinright_at(roomba, vel);
+    return Qnil;
+}
+
+static VALUE 
+set_velocity(VALUE self, VALUE rb_vel)
+{
+    struct Roomba *roomba;
+    int vel;
+
+    vel = NUM2INT(rb_vel);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_set_velocity(roomba, vel);
+    return Qnil;
+}
+
+static VALUE 
+get_velocity(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    return INT2NUM(roomba_get_velocity(roomba));
+}
+
+static VALUE 
+play_note(VALUE self, VALUE rb_note, VALUE rb_duration)
+{
+    struct Roomba *roomba;
+    uint8_t note, duration;
+
+    note = NUM2INT(rb_note);
+    duration = NUM2INT(rb_duration);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_play_note(roomba, note, duration);
+    return Qnil;
+}
+
+static VALUE 
+set_motors(VALUE self, VALUE rb_mainbrush, VALUE rb_vacuum, 
+           VALUE rb_sidebrush)
+{
+    struct Roomba *roomba;
+    uint8_t mainbrush, vacuum, sidebrush;
+
+    mainbrush = NUM2INT(rb_mainbrush);
+    vacuum = NUM2INT(rb_vacuum);
+    sidebrush = NUM2INT(rb_sidebrush);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_set_motors(roomba, mainbrush, vacuum, sidebrush);
+    return Qnil;
+}
+
+static VALUE
+set_leds(VALUE self, VALUE rb_status_green, VALUE rb_status_red,
+         VALUE rb_spot, VALUE rb_clean, VALUE rb_max, VALUE rb_dirt,
+         VALUE rb_power_color, VALUE rb_power_intensity)
+{
+    struct Roomba *roomba;
+    uint8_t status_green, status_red, spot, clean, max, dirt;
+    uint8_t power_color, power_intensity;
+
+    status_green = NUM2INT(rb_status_green);
+    status_red = NUM2INT(rb_status_red);
+    spot = NUM2INT(rb_spot);
+    clean = NUM2INT(rb_clean);
+    max = NUM2INT(rb_max);
+    dirt = NUM2INT(rb_dirt);
+    power_color = NUM2INT(rb_power_color);
+    power_intensity = NUM2INT(rb_power_intensity);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_set_leds(roomba, status_green, status_red, spot, clean,
+                    max, dirt, power_color, power_intensity);
+    return Qnil;
+}
+
+static VALUE
+vacuum(VALUE self, VALUE rb_state)
+{
+    struct Roomba *roomba;
+    uint8_t state;
+
+    state = NUM2INT(rb_state);
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_vacuum(roomba, state);
+    return Qnil;
+}
+
+static VALUE
+read_sensors(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    return INT2NUM(roomba_read_sensors(roomba));
+}
+
+static VALUE
+print_sensors(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_print_sensors(roomba);
+    return Qnil;
+}
+
+static VALUE
+print_raw_sensors(VALUE self)
+{
+    struct Roomba *roomba;
+
+    Data_Get_Struct(self, struct Roomba, roomba);
+    roomba_print_raw_sensors(roomba);
+    return Qnil;
+}
+
+static VALUE
+delay(VALUE self, VALUE rb_millisecs)
+{
+    int millisecs;
+
+    millisecs = NUM2INT(rb_millisecs);
+    roomba_delay(millisecs);
+    return Qnil;
+}
+
+void Init_roomba(){
+    cRoomba = rb_define_class("Roomba", rb_cObject);
+    rb_define_singleton_method(cRoomba, "new", roomba_new, 1);
+    rb_define_method(cRoomba, "close", close, 0);
+    rb_define_method(cRoomba, "valid", valid, 0);
+    rb_define_method(cRoomba, "get_portpath", get_portpath, 0);
+    rb_define_method(cRoomba, "send", send, 2);
+    rb_define_method(cRoomba, "drive", drive, 2);
+    rb_define_method(cRoomba, "stop", stop, 0);
+    rb_define_method(cRoomba, "forward", forward, 0);
+    rb_define_method(cRoomba, "forward_at", forward_at, 1);
+    rb_define_method(cRoomba, "backward", backward, 0);
+    rb_define_method(cRoomba, "backward_at", backward_at, 1);
+    rb_define_method(cRoomba, "spinleft", spinleft, 0);
+    rb_define_method(cRoomba, "spinleft_at", spinleft_at, 1);
+    rb_define_method(cRoomba, "spinright", spinright, 0);
+    rb_define_method(cRoomba, "spinright_at", spinright_at, 1);
+    rb_define_method(cRoomba, "set_velocity", set_velocity, 1);
+    rb_define_method(cRoomba, "get_velocity", get_velocity, 0);
+    rb_define_method(cRoomba, "play_note", play_note, 2);
+    rb_define_method(cRoomba, "set_motors", set_motors, 3);
+    rb_define_method(cRoomba, "set_leds", set_leds, 8);
+    rb_define_method(cRoomba, "vacuum", vacuum, 1);
+    rb_define_method(cRoomba, "read_sensors", read_sensors, 0);
+    rb_define_method(cRoomba, "print_sensors", print_sensors, 0);
+    rb_define_method(cRoomba, "print_raw_sensors", print_raw_sensors, 0);
+    rb_define_method(cRoomba, "delay", delay, 0);
+}

data/ext/roombalib.c

@@ -0,0 +1,302 @@
+/*
+ * roombalib -- Roomba C API
+ *
+ * http://hackingroomba.com/
+ *
+ * Copyright (C) 2006, Tod E. Kurt, tod@todbot.com
+ *
+ * Updates:
+ * 14 Dec 2006 - added more functions to roombalib
+ */
+
+
+#include <stdio.h>    /* Standard input/output definitions */
+#include <stdint.h>   /* Standard types */
+#include <stdlib.h>   /* calloc, strtol */
+#include <string.h>   /* strcpy */
+#include <unistd.h>   /* UNIX standard function definitions */
+#include <fcntl.h>    /* File control definitions */
+#include <errno.h>    /* Error number definitions */
+#include <termios.h>  /* POSIX terminal control definitions */
+#include <sys/ioctl.h>
+
+#include "roombalib.h"
+
+int roombadebug = 0;
+
+// internal use only
+int roomba_init_serialport( const char* serialport, speed_t baud );
+
+Roomba* roomba_init( const char* portpath ) 
+{
+    int fd = roomba_init_serialport( portpath, B57600 );
+    if( fd == -1 ) return NULL;
+    uint8_t cmd[1];
+    
+    cmd[0] = 128;      // START
+    int n = write(fd, cmd, 1);
+    if( n!=1 ) {
+        perror("open_port: Unable to write to port ");
+        return NULL;
+    }
+    roomba_delay(COMMANDPAUSE_MILLIS);
+    
+    cmd[0] = 130;   // CONTROL
+    n = write(fd, cmd, 1);
+    if( n!=1 ) {
+        perror("open_port: Unable to write to port ");
+        return NULL;
+    }
+    roomba_delay(COMMANDPAUSE_MILLIS);
+
+    Roomba* roomba = calloc( 1, sizeof(Roomba) );
+    roomba->fd = fd;
+    strcpy(roomba->portpath, portpath);
+    roomba->velocity = DEFAULT_VELOCITY;
+
+    return roomba;
+}
+
+void roomba_free( Roomba* roomba ) 
+{
+    if( roomba!= NULL ) {
+        if( roomba->fd ) roomba_close( roomba );
+        free( roomba );
+    }
+}
+
+const char* roomba_get_portpath( Roomba* roomba )
+{
+    return roomba->portpath;
+}
+
+void roomba_close( Roomba* roomba )
+{
+    close( roomba->fd );
+    roomba->fd = 0;
+}
+
+// is this Roomba pointer valid (but not necc connected)
+int roomba_valid( Roomba* roomba )
+{
+    return (roomba!=NULL && roomba->fd != 0);
+}
+
+void roomba_set_velocity( Roomba* roomba, int vel )
+{
+    roomba->velocity = vel;
+}
+
+int roomba_get_velocity( Roomba* roomba )
+{
+    return roomba->velocity;
+}
+
+// send an arbitrary length roomba command
+int roomba_send( Roomba* roomba, const uint8_t* cmd, int len )
+{
+    int n = write( roomba->fd, cmd, len);
+    if( n!=len )
+        perror("roomba_send: couldn't write to roomba");
+    return (n!=len); // indicate error, can usually ignore
+}
+
+// Move Roomba with low-level DRIVE command
+void roomba_drive( Roomba* roomba, int velocity, int radius )
+{
+    uint8_t vhi = velocity >> 8;
+    uint8_t vlo = velocity & 0xff;
+    uint8_t rhi = radius   >> 8;
+    uint8_t rlo = radius   & 0xff;
+    if(roombadebug) 
+        fprintf(stderr,"roomba_drive: %.2hhx %.2hhx %.2hhx %.2hhx\n",
+                vhi,vlo,rhi,rlo);
+    uint8_t cmd[] = { 137, vhi,vlo, rhi,rlo };  // DRIVE
+    int n = write(roomba->fd, cmd, 5);
+    if( n!=5 )
+        perror("roomba_drive: couldn't write to roomba");
+}
+
+void roomba_stop( Roomba* roomba )
+{
+    roomba_drive( roomba, 0, 0 );
+}
+
+void roomba_forward( Roomba* roomba )
+{
+    roomba_drive( roomba, roomba->velocity, 0x8000 );  // 0x8000 = straight
+}
+void roomba_forward_at( Roomba* roomba, int velocity )
+{
+    roomba_drive( roomba, velocity, 0x8000 );
+}
+
+void roomba_backward( Roomba* roomba )
+{
+    roomba_drive( roomba, -roomba->velocity, 0x8000 );
+}
+void roomba_backward_at( Roomba* roomba, int velocity )
+{
+    roomba_drive( roomba, -velocity, 0x8000 );
+}
+
+void roomba_spinleft( Roomba* roomba )
+{
+    roomba_drive( roomba, roomba->velocity, 1 );
+}
+void roomba_spinleft_at( Roomba* roomba, int velocity )
+{
+    roomba_drive( roomba, velocity, 1 );
+}
+
+void roomba_spinright( Roomba* roomba )
+{
+    roomba_drive( roomba, roomba->velocity,  -1 );
+}
+void roomba_spinright_at( Roomba* roomba, int velocity )
+{
+    roomba_drive( roomba, velocity,  -1 );
+}
+
+void roomba_play_note( Roomba* roomba, uint8_t note, uint8_t duration ) 
+{
+    uint8_t cmd[] = { 140, 15, 1, note, duration, // SONG, then
+                      141, 15 };                  // PLAY
+    int n = write( roomba->fd, cmd, 7);
+    if( n!=7 )
+        perror("roomba_play_note: couldn't write to roomba");
+}
+
+// Turns on/off the non-drive motors (main brush, vacuum, sidebrush).
+void roomba_set_motors( Roomba* roomba, uint8_t mainbrush, uint8_t vacuum, uint8_t sidebrush)
+{
+    uint8_t cmd[] = { 138,                        // MOTORS
+                      ((mainbrush?0x04:0)|(vacuum?0x02:0)|(sidebrush?0x01:0))};
+    int n = write( roomba->fd, cmd, 2);
+    if( n!=2 )
+        perror("roomba_set_motors: couldn't write to roomba");
+}
+
+// Turns on/off the various LEDs.
+void roomba_set_leds( Roomba* roomba, uint8_t status_green, uint8_t status_red,
+                      uint8_t spot, uint8_t clean, uint8_t max, uint8_t dirt, 
+                      uint8_t power_color, uint8_t power_intensity )
+{
+    uint8_t v = (status_green?0x20:0) | (status_red?0x10:0) |
+                (spot?0x08:0) | (clean?0x04:0) | (max?0x02:0) | (dirt?0x01:0);
+    uint8_t cmd[] = { 139, v, power_color, power_intensity }; // LEDS
+    int n = write( roomba->fd, cmd, 4);
+    if( n!=4 )
+        perror("roomba_set_leds: couldn't write to roomba");
+}
+
+// Turn all vacuum motors on or off according to state
+void roomba_vacuum( Roomba* roomba, uint8_t state ) {
+    roomba_set_motors( roomba, state,state,state);
+}
+
+int roomba_read_sensors( Roomba* roomba )
+{
+    uint8_t cmd[] = { 142, 0 };          // SENSOR, get all sensor data
+    int n = write( roomba->fd, cmd, 2);
+    roomba_delay(COMMANDPAUSE_MILLIS);  //hmm, why isn't VMIN & VTIME working?
+    n = read( roomba->fd, roomba->sensor_bytes, 26);
+    if( n!=26 ) {
+        if(roombadebug)
+            fprintf(stderr,"roomba_read_sensors: not enough read (n=%d)\n",n);
+        return -1;
+    }
+    return 0;
+}
+
+void roomba_print_raw_sensors( Roomba* roomba )
+{
+    uint8_t* sb = roomba->sensor_bytes;
+    int i;
+    for(i=0;i<26;i++) {
+        printf("%.2hhx ",sb[i]);
+    }
+    printf("\n");
+}
+
+void roomba_print_sensors( Roomba* roomba )
+{
+    uint8_t* sb = roomba->sensor_bytes;
+    printf("bump: %x %x\n", bump_left(sb[0]), bump_right(sb[0]));
+    printf("wheeldrop: %x %x %x\n", wheeldrop_left(sb[0]),
+           wheeldrop_caster(sb[0]), wheeldrop_right(sb[0]));
+    printf("wall: %x\n", sb[1]);
+    printf("cliff: %x %x %x %x\n", sb[2],sb[3],sb[4],sb[5] );
+    printf("virtual_wall: %x\n", sb[6]);
+    printf("motor_overcurrents: %x %x %x %x %x\n", motorover_driveleft(sb[7]),
+           motorover_driveright(sb[7]), motorover_mainbrush(sb[7]),
+           motorover_sidebrush(sb[7]),  motorover_vacuum(sb[7]));
+    printf("dirt: %x %x\n", sb[8],sb[9]);
+    printf("remote_opcode: %.2hhx\n", sb[10]);
+    printf("buttons: %.2hhx\n", sb[11]);
+    printf("distance: %.4x\n",    (sb[12]<<8) | sb[13] );
+    printf("angle: %.4x\n",       (sb[14]<<8) | sb[15] );
+    printf("charging_state: %.2hhx\n", sb[16]);
+    printf("voltage: %d\n",     (sb[17]<<8) | sb[18] );
+    printf("current: %d\n",     ((int8_t)sb[19]<<8) | sb[20] );
+    printf("temperature: %d\n",    sb[21]);
+    printf("charge: %d\n",      (sb[22]<<8) | sb[23] );
+    printf("capacity: %d\n",    (sb[24]<<8) | sb[25] );
+}
+
+// 100,000 us == 100 ms == 0.1s
+void roomba_delay( int millisecs )
+{
+    usleep( millisecs * 1000 );
+}
+
+
+
+// private
+// returns valid fd, or -1 on error
+int roomba_init_serialport( const char* serialport, speed_t baud )
+{
+    struct termios toptions;
+    int fd;
+
+    if(roombadebug)
+        fprintf(stderr,"roomba_init_serialport: opening port %s\n",serialport);
+
+    fd = open( serialport, O_RDWR | O_NOCTTY | O_NDELAY );
+    if (fd == -1)  {     // Could not open the port.
+        perror("roomba_init_serialport: Unable to open port ");
+        return -1;
+    }
+    
+    if (tcgetattr(fd, &toptions) < 0) {
+        perror("roomba_init_serialport: Couldn't get term attributes");
+        return -1;
+    }
+    
+    cfsetispeed(&toptions, baud);
+    cfsetospeed(&toptions, baud);
+
+    // 8N1
+    toptions.c_cflag &= ~PARENB;
+    toptions.c_cflag &= ~CSTOPB;
+    toptions.c_cflag &= ~CSIZE;
+    toptions.c_cflag |= CS8;
+    // no flow control
+    toptions.c_cflag &= ~CRTSCTS;
+
+    toptions.c_cflag    |= CREAD | CLOCAL;  // turn on READ & ignore ctrl lines
+    toptions.c_iflag    &= ~(IXON | IXOFF | IXANY); // turn off s/w flow ctrl
+
+    toptions.c_lflag    &= ~(ICANON | ECHO | ECHOE | ISIG); // make raw
+    toptions.c_oflag    &= ~OPOST; // make raw
+
+    toptions.c_cc[VMIN]  = 26;
+    toptions.c_cc[VTIME] = 2;           // FIXME: not sure about this
+    
+    if( tcsetattr(fd, TCSANOW, &toptions) < 0) {
+        perror("roomba_init_serialport: Couldn't set term attributes");
+        return -1;
+    }
+
+    return fd;
+}

data/ext/roombalib.h

@@ -0,0 +1,118 @@
+/*
+ * roombalib -- Roomba C API
+ *
+ * http://hackingroomba.com/
+ *
+ * Copyright (C) 2006, Tod E. Kurt, tod@todbot.com
+ * 
+ * Updates:
+ * 14 Dec 2006 - added more functions to roombalib
+ */
+
+
+#include <stdint.h>   /* Standard types */
+
+#define DEFAULT_VELOCITY 200
+#define COMMANDPAUSE_MILLIS 100
+
+// holds all the per-roomba info
+// consider it an opaque blob, please
+typedef struct Roomba_struct {
+    int fd;
+    char portpath[80];
+    uint8_t sensor_bytes[26];
+    int velocity;
+} Roomba;
+
+// set to non-zero to see debugging output
+extern int roombadebug;
+
+// given a serial port name, create a Roomba object and return it
+// or return NULL on error
+Roomba* roomba_init( const char* portname );
+
+// frees the memory of the Roomba object created with roomba_init
+// will close the serial port if it's open
+void roomba_free( Roomba* roomba );
+
+// close the serial port connected to the Roomba
+void roomba_close( Roomba* roomba );
+
+// is this Roomba pointer valid (but not necc connected)
+int roomba_valid( Roomba* roomba );
+
+// return the serial port path for the given roomba
+const char* roomba_get_portpath( Roomba* roomba );
+
+// send an arbitrary length roomba command
+int roomba_send( Roomba* roomba, const uint8_t* cmd, int len );
+
+// Move Roomba with low-level DRIVE command
+void roomba_drive( Roomba* roomba, int velocity, int radius );
+
+// stop the Roomba 
+void roomba_stop( Roomba* roomba );
+
+// Move Roomba forward at current velocity
+void roomba_forward( Roomba* roomba );
+void roomba_forward_at( Roomba* roomba, int velocity );
+
+// Move Roomba backward at current velocity
+void roomba_backward( Roomba* roomba );
+void roomba_backward_at( Roomba* roomba, int velocity );
+
+// Spin Roomba left at current velocity
+void roomba_spinleft( Roomba* roomba );
+void roomba_spinleft_at( Roomba* roomba, int velocity );
+
+// Spin Roomba right at current velocity
+void roomba_spinright( Roomba* roomba );
+void roomba_spinright_at( Roomba* roomba, int velocity );
+
+// Set current velocity for higher-level movement commands
+void roomba_set_velocity( Roomba* roomba, int velocity );
+
+// Get current velocity for higher-level movement commands
+int roomba_get_velocity( Roomba* roomba );
+
+// play a musical note
+void roomba_play_note( Roomba* roomba, uint8_t note, uint8_t duration );
+
+// Turns on/off the non-drive motors (main brush, vacuum, sidebrush).
+void roomba_set_motors( Roomba* roomba, uint8_t mainbrush, uint8_t vacuum, uint8_t sidebrush);
+
+// Turns on/off the various LEDs.
+void roomba_set_leds( Roomba* roomba, uint8_t status_green, uint8_t status_red,
+                      uint8_t spot, uint8_t clean, uint8_t max, uint8_t dirt, 
+                      uint8_t power_color, uint8_t power_intensity );
+
+// Turn all vacuum motors on or off according to state
+void roomba_vacuum( Roomba* roomba, uint8_t state );
+
+// Get the sensor data from the Roomba
+// returns -1 on failure
+int roomba_read_sensors( Roomba* roomba );
+
+// print existing sensor data nicely
+void roomba_print_sensors( Roomba* roomba );
+
+// print existing sensor data as string of hex chars
+void roomba_print_raw_sensors( Roomba* roomba );
+
+// utility function
+void roomba_delay( int millisecs );
+#define roomba_wait roomba_delay
+
+// some simple macros of bit manipulations
+#define bump_right(b)           ((b & 0x01)!=0)
+#define bump_left(b)            ((b & 0x02)!=0)
+#define wheeldrop_right(b)      ((b & 0x04)!=0)
+#define wheeldrop_left(b)       ((b & 0x08)!=0)
+#define wheeldrop_caster(b)     ((b & 0x10)!=0)
+
+#define motorover_sidebrush(b)  ((b & 0x01)!=0) 
+#define motorover_vacuum(b)     ((b & 0x02)!=0) 
+#define motorover_mainbrush(b)  ((b & 0x04)!=0) 
+#define motorover_driveright(b) ((b & 0x08)!=0) 
+#define motorover_driveleft(b)  ((b & 0x10)!=0) 
+

data/spec/roomba_spec.rb

@@ -0,0 +1,7 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe "Roomba" do
+  it "fails" do
+    fail "hey buddy, you should probably rename this file and start specing for real"
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'roomba'
+require 'spec'
+require 'spec/autorun'
+
+Spec::Runner.configure do |config|
+  
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification 
+name: roomba
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Doug P.
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-08-28 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+description: Library to control a Roomba
+email: dougtko@gmail.com
+executables: []
+
+extensions: 
+- ext/extconf.rb
+extra_rdoc_files: 
+- LICENSE
+- README.rdoc
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.rdoc
+- Rakefile
+- VERSION
+- ext/extconf.rb
+- ext/roomba.c
+- ext/roombalib.c
+- ext/roombalib.h
+- lib/roomba.rb
+- spec/roomba_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/dougsko/roomba
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Library to control a Roomba
+test_files: 
+- spec/roomba_spec.rb
+- spec/spec_helper.rb