tuxdroid 0.1.0

data/History.txt

@@ -0,0 +1,3 @@
+== 0.1.0 / 2007-03-23
+
+* Packaged as a gem

data/LICENSE.txt

@@ -0,0 +1,340 @@
+		    GNU GENERAL PUBLIC LICENSE
+		       Version 2, June 1991
+
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+			    Preamble
+
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+		    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+			    NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+		     END OF TERMS AND CONDITIONS
+
+	    How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
+

data/Manifest.txt

@@ -0,0 +1,8 @@
+History.txt
+Manifest.txt
+README.txt
+LICENSE.txt
+Rakefile
+lib/tuxdroid.rb
+lib/tuxdroid/constants.rb
+test/test_tuxdroid.rb

data/README.txt

@@ -0,0 +1,50 @@
+TuxDroid
+    by Andrew Montgomery
+    http://www.darkliquid.co.uk
+
+== DESCRIPTION:
+  
+A Ruby Command Interface for the TuxDroid from Kysoh
+See: http://www.tuxisalive.com for more info
+
+== FEATURES/PROBLEMS:
+  
+* Simple interface to all basic actions
+* No sound support yet
+* No reading the status of any motors or sensors yet
+
+== SYNOPSIS:
+
+  require 'tuxdroid'
+  tux = TuxDroid::Tux.new
+  tux.mouth :open
+  tux.mouth :close
+  tux.wings :flap, :times => 2, :speed => 3 
+
+== REQUIREMENTS:
+
+* ruby-usb svn version (last tested with revision 512)
+* libusb  
+
+== INSTALL:
+
+* sudo gem install tuxdroid
+
+== LICENSE:
+
+(The GPL2 License)
+
+Copyright (c) 2007 Andrew Montgomery
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; version 2 ONLY.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License along
+with this program; if not, write to the Free Software Foundation, Inc.,
+51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

data/Rakefile

@@ -0,0 +1,15 @@
+# -*- ruby -*-
+
+require 'rubygems'
+require 'hoe'
+require './lib/tuxdroid'
+
+Hoe.new('tuxdroid', TuxDroid::VERSION) do |p|
+  p.rubyforge_name = 'tuxdroid'
+  p.summary = 'A Ruby Command Interface API to the TuxDroid from Kysoh'
+  p.description = p.paragraphs_of('README.txt', 2..5).join("\n\n")
+  p.url = p.paragraphs_of('README.txt', 0).first.split(/\n/)[1..-1]
+  p.changes = p.paragraphs_of('History.txt', 0..1).join("\n\n")
+end
+
+# vim: syntax=Ruby

data/lib/tuxdroid.rb

@@ -0,0 +1,210 @@
+# TuxDroid module - everything to do with Tux Droid
+#
+# License: GPL2 
+#
+# Copyright: Andrew Montgomery <darkliquid@darkliquid.co.uk>
+#
+
+require 'usb'
+require File.dirname(__FILE__) + '/tuxdroid/constants.rb'
+
+module TuxDroid
+  
+  # Tux Interface Class
+  # 
+  class Tux
+
+    include USBCodes
+
+    attr_reader :usb_status
+
+    # Creates a new interface between ruby and the TuxDroid
+    def initialize
+      @tux_device = self.class.get_usb_device()
+      @tux_handle = self.class.get_usb_interface(@tux_device)
+      @usb_status = :connected
+    end
+
+    #
+    # Command wrappers to low-level send_command routine
+    #
+
+    # Accepts:
+    # * :open => opens mouth
+    # * :closes => closes mouth
+    # * :move => toggles mouth (specify option ":times => n" for n amount of toggles)
+    def mouth(cmd, options = {})
+      validate_within(options, :times => 0..255)
+      case cmd
+        when :open
+          send_command(Actions::OPEN_MOUTH)
+        when :close
+          send_command(Actions::CLOSE_MOUTH)
+        when :move
+          send_command(Actions::MOVE_MOUTH, options[:times] || 1)
+        else
+          raise UnknownTuxDroidActionError.new("Command: #{cmd.inspect} Options: #{options.inspect}")
+      end
+    end
+    
+    # Accepts:
+    # * :open => opens eyes
+    # * :closes => closes eyes
+    # * :blink => toggles eyes (specify option ":times => n" for n amount of toggles)
+    # * :stop => stops current eye motions
+    def eyes(cmd, options = {})
+      validate_within(options, :times => 0..255)
+      case cmd
+        when :open
+          send_command(Actions::OPEN_EYES)
+        when :close
+          send_command(Actions::BLINK_EYES, 1)
+        when :blink
+          send_command(Actions::BLINK_EYES, options[:times] || 1)
+        when :stop
+          send_command(Actions::STOP_EYES)
+        else
+          raise UnknownTuxDroidActionError.new("Command: #{cmd.inspect} Options: #{options.inspect}")
+      end    
+    end
+    
+    # Accepts:
+    # * :toggle => toggles wings, options are :speed => (1..5)
+    # * :reset => runs wing reset routine (flaps twice)
+    # * :flap => toggles wings, options are :times => n (n amount of times), :speed => (1..5)
+    def wings(cmd, options = {})
+      validate_within(options, :times => 0..255, :speed => 1..5)
+      case cmd
+        when :toggle
+          send_command(Actions::WAVE_WINGS, 1, options[:speed] || 3)
+        when :reset
+          send_command(Actions::RESET_WINGS)
+        when :flap
+          send_command(Actions::WAVE_WINGS, options[:times] || 1, options[:speed] || 3)
+        else
+          raise UnknownTuxDroidActionError.new("Command: #{cmd.inspect} Options: #{options.inspect}")
+      end        
+    end
+    
+    # Accepts:
+    # * :left => spins left roughly 90 degrees, options are :times => n (n amount of times), :speed => (1..5)
+    # * :right => spins right roughly 90 degrees, options are :times => n (n amount of times), :speed => (1..5)
+    # * :stop => stops current spinning motion
+    def spin(cmd, options = {})
+      validate_within(options, :times => 0..255, :speed => 1..5)
+      case cmd
+        when :left
+          send_command(Actions::SPIN_LEFT, options[:times] || 1, options[:speed] || 3)
+        when :right
+          send_command(Actions::SPIN_RIGHT, options[:times] || 1, options[:speed] || 3)
+        when :stop
+          send_command(Actions::STOP_SPIN)
+        else
+          raise UnknownTuxDroidActionError.new("Command: #{cmd.inspect} Options: #{options.inspect}")
+      end        
+    end
+
+    # Accepts:
+    # * :on => light up both eyes
+    # * :off => turn off both eyes
+    # * :left_on => light up left eye
+    # * :left_off => turn off left eye
+    # * :right_on => light up right eye
+    # * :right_off => turn off right eye
+    # * :blink => blink both eyes, options are :times => n (n amount of blinks), :delay => n (n x 4ms delay between blinks)
+    def leds(cmd, options = {})
+      validate_within(options, :times => 0..255, :delay => 0..255)
+      case cmd
+        when :on
+          send_command(Actions::LED_ON)
+        when :off
+          send_command(Actions::LED_OFF)
+        when :left_on
+          send_command(Actions::LED_LEFT_ON)
+        when :left_off
+          send_command(Actions::LED_LEFT_OFF)
+        when :right_on
+          send_command(Actions::LED_RIGHT_ON)
+        when :right_off
+          send_command(Actions::LED_RIGHT_OFF)
+        when :blink
+          send_command(Actions::LED_BLINK, options[:times] || 1, options[:delay] || 20)
+        else
+          raise UnknownTuxDroidActionError.new("Command: #{cmd.inspect} Options: #{options.inspect}")
+      end        
+    end
+
+    #
+    # Command validators
+    #
+
+    private
+    
+    def validate_within(options, checks)
+      checks.each do |k,v|
+        unless options[k].nil? or v.include?(options[k])
+          raise TuxDroidCommandOptionsError.new("#{k.inspect} is not within #{v.inspect}")
+        end
+      end
+    end
+
+    #
+    # Low-level methods
+    #
+
+    private
+    
+    def self.get_usb_device
+      tux_device = USB.devices.find {|d| d.idProduct == PRODUCT_ID and d.idVendor == VENDOR_ID }
+      raise USBDeviceNotFoundError  if tux_device.nil?
+      raise FirmwareTooOldError     if tux_device.bcdDevice < FIRMWARE_REV
+      return tux_device
+    end
+    
+    def self.get_usb_interface(tux_device)
+      tux_handle = tux_device.open
+      raise CannotOpenDeviceError if tux_handle.nil?
+  
+      retries = 0
+      begin
+        error_code = tux_handle.usb_claim_interface(INTERFACE)
+        raise CannotClaimInterfaceError unless error_code.nil?
+      rescue CannotClaimInterfaceError
+        tux_handle.usb_detach_kernel_driver_np(INTERFACE);
+        if retries.zero? 
+          retries += 1
+          retry
+        else
+          raise $!
+        end
+      end
+      
+      error_code = tux_handle.set_altinterface(0)
+      raise CannotSetAlternativeInterfaceError unless error_code.nil?
+  
+      tux_handle
+    end
+  
+    def send_command(command, param1 = 0, param2 = 0, param3 = 0)
+      bytes = [0]
+      bytes << command
+      bytes << param1.to_i
+      bytes << param2.to_i
+      bytes << param3.to_i
+      @tux_handle.usb_interrupt_write(WRITE_ENDPOINT, bytes.pack('C*'), WRITE_TIMEOUT)
+    end
+    
+    def get_status
+      # Send a dongle command (I think)
+      @tux_handle.usb_interrupt_write(WRITE_ENDPOINT, [1,1,0,0,0].pack('C*'), WRITE_TIMEOUT)
+      # Build an empty binary string
+      data_pack = ([0]*64).pack('C*')
+      # Read usb data into binary string
+      @tux_handle.usb_interrupt_read(READ_ENDPOINT, data_pack, READ_TIMEOUT)
+      # Return the result as an array
+      return data_pack.unpack('C*')
+    end
+    
+  end
+  
+end

data/lib/tuxdroid/constants.rb

@@ -0,0 +1,150 @@
+module TuxDroid
+
+  VERSION = '0.1.0'
+
+  module Actions
+    BLINK_EYES    = 0x40  # param1: number
+    STOP_EYES     = 0x32
+    OPEN_EYES     = 0x33
+    MOVE_MOUTH    = 0x41  # param1: number
+    
+    OPEN_MOUTH    = 0x34
+    CLOSE_MOUTH   = 0x35
+    STOP_MOUTH    = 0x36
+    WAVE_WINGS    = 0x80  # param1: number, param2: speed (1-5)
+    
+    STOP_WINGS    = 0x30
+    RESET_WINGS   = 0x31
+    SPIN_LEFT     = 0x82  # param1: number*90 degrees, param2: speed (1-5)
+    SPIN_RIGHT    = 0x83  # param1: number*90 degrees, param2: speed (1-5)
+    STOP_SPIN     = 0x37
+    
+    TURN_IR_ON    = 0x17
+    TURN_IR_OFF   = 0x18
+    IR_SEND_RC5   = 0x91  # param1: xxTAAAAA (T: toggle bit, A: RC5 5 bits address)
+                          # param2: xxCCCCCC (C: RC5 6 bits command)
+    
+    LED_ON        = 0x1A
+    LED_OFF       = 0x1B
+    LED_LEFT_ON   = 0x1C
+    LED_LEFT_OFF  = 0x1D
+    LED_RIGHT_ON  = 0x1E
+    LED_RIGHT_OFF = 0x1F
+    LED_BLINK     = 0x9A  # param1: toggles, param2: delay*4ms
+    
+    PLAY_SOUND    = 0x90  # param1: number, param2: volume
+    STORE_SOUND   = 0x52  # param1: number
+    STORE_INDEX   = 0xD0  # param1: lower, param2: middle, param3: higher
+    TEST_SOUND    = 0x10
+    MUTE          = 0x92  # param1: state, 
+  end
+
+  module Remote
+    K_0             = 0x00
+    K_1             = 0x01
+    K_2             = 0x02
+    K_3             = 0x03
+    K_4             = 0x04
+    K_5             = 0x05
+    K_6             = 0x06
+    K_7             = 0x07
+    K_8             = 0x08
+    K_9             = 0x09
+    K_STANDBY       = 0x0C
+    K_MUTE          = 0x0D
+    K_VOLUMEPLUS    = 0x10
+    K_VOLUMEMINUS   = 0x11
+    K_ESCAPE        = 0x12
+    K_YES           = 0x13
+    K_NO            = 0x14
+    K_BACKSPACE     = 0x15
+    K_STARTVOIP     = 0x16
+    K_RECEIVECALL   = 0x17
+    K_HANGUP        = 0x18
+    K_STAR          = 0x19
+    K_SHARP         = 0x1A
+    K_RED           = 0x1B
+    K_GREEN         = 0x1C
+    K_BLUE          = 0x1D
+    K_YELLOW        = 0x1E
+    K_CHANNELPLUS   = 0x20
+    K_CHANNELMINUS  = 0x21
+    K_UP            = 0x22
+    K_DOWN          = 0x23
+    K_LEFT          = 0x24
+    K_RIGHT         = 0x25
+    K_OK            = 0x26
+    K_FASTREWIND    = 0x32
+    K_FASTFORWARD   = 0x34
+    K_PLAYPAUSE     = 0x35
+    K_STOP          = 0x36
+    K_RECORDING     = 0x37
+    K_PREVIOUS      = 0x38
+    K_NEXT          = 0x39
+    K_MENU          = 0x3A
+    K_MOUSE         = 0x3B
+    K_ALT           = 0x3C
+  end
+  
+  module Status
+    WINGS_MOTOR_BACKWARD        = 0x01
+    SPIN_MOTOR_BACKWARD         = 0x02
+    SPIN_MOTOR_FORWARD          = 0x03
+    MOUTH_OPEN_POSITION         = 0x04
+    MOUTH_CLOSED_POSITION       = 0x05
+    HEAD_PUSH_POSITION          = 0x06
+    CHARGER_INHIBIT_SIGNAL      = 0x07
+    WINGS_POSITION_SWITCH       = 0x08
+    MOTOR_FOR_WINGS             = 0x09
+    LEFT_BLUE_LED               = 0x0A
+    I2C_SDA_LINE                = 0x0B
+    I2C_SCL_LINE                = 0x0C
+    HEAD_MOTOR_FOR_MOUTH        = 0x0D
+    HEAD_MOTOR_FOR_EYES         = 0x0E
+    IR_RECEIVER_SIGNAL          = 0x0F
+    SPIN_POSITION_SWITCH        = 0x10
+    WINGS_MOTOR_FORWARD         = 0x11
+    IR_LED                      = 0x12
+    EYES_OPEN_POSITION_SWITCH   = 0x13
+    EYES_CLOSED_POSITION_SWITCH = 0x14
+    LEFT_WING_PUSH              = 0x15
+    RIGHT_WING_PUSH             = 0x16
+    POWER_PLUG_SWITCH           = 0x17
+    HEAD_PUSH_SWITCH            = 0x18
+    CHARGER_LED_STATUS          = 0x19
+    MUTE_STATUS                 = 0x1A
+    LIGHT_LEVEL                 = 0x1B
+    EYES_POSITION_COUNTER       = 0x1C
+    MOUTH_POSITION_COUNTER      = 0x1D
+    WINGS_POSITION_COUNTER      = 0x1E
+    SPIN_POSITION_COUNTER       = 0x1F
+    RIGHT_BLUE_LED              = 0x20
+    RF_CONNECTED                = 0x21
+    IR_CODE                     = 0x22
+    SOUND_COUNT                 = 0x23
+    PONG                        = 0x24
+  end
+  
+  module USBCodes
+    # Constants
+    PRODUCT_ID     = 0xFF07
+    VENDOR_ID      = 0x03EB
+    FIRMWARE_REV   = 0x100
+    INTERFACE      = 0x03
+    RECV_LENGTH    = 0x05
+    SEND_LENGTH    = 0x05
+    WRITE_ENDPOINT = 0x05
+    READ_ENDPOINT  = 0x84
+    WRITE_TIMEOUT  = 5000
+    READ_TIMEOUT   = 5000
+  end
+  
+  # Tux Exceptions
+  class FirmwareTooOldError                 < StandardError; end
+  class CannotOpenDeviceError               < StandardError; end
+  class CannotClaimInterfaceError           < StandardError; end
+  class CannotSetAlternativeInterfaceError  < StandardError; end
+  class UnknownTuxDroidActionError          < StandardError; end
+  class TuxDroidCommandOptionsError         < StandardError; end
+  class USBDeviceNotFoundError              < StandardError; end
+end 

data/test/test_tuxdroid.rb

@@ -0,0 +1,363 @@
+require './lib/tuxdroid.rb'
+require 'test/unit'
+require 'rubygems'
+require 'mocha'
+
+class TuxDroidTest < Test::Unit::TestCase
+
+  #
+  # Eye tests
+  #
+
+  def test_eyes_open
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::OPEN_EYES)
+    end
+    assert_nothing_raised { tux.eyes :open  }
+  end  
+  
+  def test_eyes_close
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::BLINK_EYES, 1)
+    end
+    assert_nothing_raised { tux.eyes :close }
+  end
+  
+  def test_eyes_blink
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::BLINK_EYES, 1)
+    end
+    assert_nothing_raised { tux.eyes :blink }
+  end
+
+  def test_eyes_blink_3_times
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::BLINK_EYES, 3)
+    end
+    assert_nothing_raised { tux.eyes :blink, :times => 3 }
+  end
+  
+  def test_eyes_stop
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::STOP_EYES)
+    end
+    assert_nothing_raised { tux.eyes :stop  }
+  end
+  
+  def test_eyes_raise_on_unknown_action
+    tux = setup_tux
+    assert_raises(TuxDroid::UnknownTuxDroidActionError) { tux.eyes :explode }
+  end
+
+  #
+  # LED tests
+  #
+
+  def test_leds_both_turn_on
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_ON)
+    end
+    assert_nothing_raised { tux.leds :on  }
+  end
+
+  def test_leds_both_turn_off
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_OFF)
+    end
+    assert_nothing_raised { tux.leds :off  }
+  end
+
+  def test_leds_left_turn_on
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_LEFT_ON)
+    end
+    assert_nothing_raised { tux.leds :left_on  }
+  end
+
+  def test_leds_left_turn_off
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_LEFT_OFF)
+    end
+    assert_nothing_raised { tux.leds :left_off  }
+  end
+
+  def test_leds_right_turn_on
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_RIGHT_ON)
+    end
+    assert_nothing_raised { tux.leds :right_on  }
+  end
+
+  def test_leds_right_turn_off
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_RIGHT_OFF)
+    end
+    assert_nothing_raised { tux.leds :right_off  }
+  end
+
+  def test_leds_blink
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_BLINK, 1, 20)
+    end
+    assert_nothing_raised { tux.leds :blink  }
+  end
+
+  def test_leds_blink_4_times
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_BLINK, 4, 20)
+    end
+    assert_nothing_raised { tux.leds :blink, :times => 4  }
+  end
+  
+  def test_leds_blink_4_times_with_100_delay
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::LED_BLINK, 4, 100)
+    end
+    assert_nothing_raised { tux.leds :blink, :times => 4, :delay => 100 }
+  end
+  
+  def test_leds_raise_on_unknown_action
+    tux = setup_tux
+    assert_raises(TuxDroid::UnknownTuxDroidActionError) { tux.leds :explode }
+  end
+
+  #
+  # Mouth tests
+  #
+
+  def test_mouth_opens
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::OPEN_MOUTH)
+    end
+    assert_nothing_raised { tux.mouth :open }
+  end
+
+  def test_mouth_closes
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::CLOSE_MOUTH)
+    end
+    assert_nothing_raised { tux.mouth :close }
+  end
+  
+  def test_mouth_moves
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::MOVE_MOUTH, 1)
+    end
+    assert_nothing_raised { tux.mouth :move }
+  end
+
+  def test_mouth_moves_3_times
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::MOVE_MOUTH, 3)
+    end
+    assert_nothing_raised { tux.mouth :move, :times => 3 }
+  end
+
+  def test_mouth_raise_on_unknown_action
+    tux = setup_tux
+    assert_raises(TuxDroid::UnknownTuxDroidActionError) { tux.mouth :explode }
+  end
+
+  #
+  # Spin tests
+  #
+
+  def test_spin_left
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_LEFT, 1, 3)
+    end
+    assert_nothing_raised { tux.spin :left }
+  end
+
+  def test_spin_left_3_times
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_LEFT, 3, 3)
+    end
+    assert_nothing_raised { tux.spin :left, :times => 3 }
+  end
+
+  def test_spin_left_3_times_fast
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_LEFT, 3, 5)
+    end
+    assert_nothing_raised { tux.spin :left, :times => 3, :speed => 5 }
+  end
+
+  def test_spin_right
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_RIGHT, 1, 3)
+    end
+    assert_nothing_raised { tux.spin :right }
+  end
+
+  def test_spin_left_3_times
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_RIGHT, 3, 3)
+    end
+    assert_nothing_raised { tux.spin :right, :times => 3 }
+  end
+
+  def test_spin_left_3_times_fast
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::SPIN_RIGHT, 3, 5)
+    end
+    assert_nothing_raised { tux.spin :right, :times => 3, :speed => 5 }
+  end
+
+  def test_spin_stop
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::STOP_SPIN)
+    end
+    assert_nothing_raised { tux.spin :stop }
+  end
+
+  def test_spin_raises_on_unknown_action
+    tux = setup_tux
+    assert_raises(TuxDroid::UnknownTuxDroidActionError) { tux.spin :explode }
+  end
+
+  #
+  # Wing tests
+  #
+
+  def test_wings_toggle
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::WAVE_WINGS, 1, 3)
+    end
+    assert_nothing_raised { tux.wings :toggle }
+  end
+
+  def test_wings_toggle_fast
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::WAVE_WINGS, 1, 5)
+    end
+    assert_nothing_raised { tux.wings :toggle, :speed => 5 }
+  end
+  
+  def test_wings_flap
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::WAVE_WINGS, 1, 3)
+    end
+    assert_nothing_raised { tux.wings :flap }
+  end
+
+  def test_wings_flap_3_times_fast
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::WAVE_WINGS, 3, 5)
+    end
+    assert_nothing_raised { tux.wings :flap, :times => 3, :speed => 5 }
+  end
+  
+  def test_wings_reset
+    tux = setup_tux do |i|
+      expect_command(i, TuxDroid::Actions::RESET_WINGS)
+    end
+    assert_nothing_raised { tux.wings :reset }
+  end
+  
+  def test_wings_raises_on_unknown_action
+    tux = setup_tux
+    assert_raises(TuxDroid::UnknownTuxDroidActionError) { tux.wings :explode }
+  end
+
+  #
+  # Initialiser tests
+  #
+
+  def test_should_raise_when_cannot_get_usb_device
+    USB.stubs(:devices).returns(stub(:find => nil))
+    assert_raises(TuxDroid::USBDeviceNotFoundError) do
+      TuxDroid::Tux.get_usb_device
+    end
+  end
+  
+  def test_should_raise_when_usb_device_firmware_is_too_old
+    device = stub(:bcdDevice => TuxDroid::USBCodes::FIRMWARE_REV-1)
+    USB.stubs(:devices).returns(stub(:find => device))
+    assert_raises(TuxDroid::FirmwareTooOldError) do
+      TuxDroid::Tux.get_usb_device
+    end
+  end
+  
+  def test_should_raise_when_cannot_open_device
+    interface = mock()
+    interface.stubs(:usb_claim_interface).returns(1)
+    interface.stubs(:usb_detach_kernel_driver_np)
+    assert_raises(TuxDroid::CannotClaimInterfaceError) do
+      TuxDroid::Tux.get_usb_interface(stub(:open => interface))
+    end
+  end
+  
+  def test_should_raise_when_cannot_set_alternative_interface
+    interface = mock()
+    interface.stubs(:usb_claim_interface).returns(nil)
+    interface.stubs(:set_altinterface).returns(1)
+    assert_raises(TuxDroid::CannotSetAlternativeInterfaceError) do
+      TuxDroid::Tux.get_usb_interface(stub(:open => interface))
+    end
+  end
+  
+  #
+  # Send command test
+  #
+  
+  def test_send_command
+    tux = setup_tux do |i|
+      i.expects(:usb_interrupt_write).with(
+        TuxDroid::USBCodes::WRITE_ENDPOINT,
+        "\000\001\001\001\001",
+        TuxDroid::USBCodes::WRITE_TIMEOUT
+      )
+    end
+    tux.send(:send_command, 1,1,1,1)
+  end
+  
+  #
+  # Validator tests
+  #
+  
+  def test_validate_within
+    tux = setup_tux
+    assert_nothing_raised do
+      tux.send(:validate_within, {:key => 5}, {:key => 1..6})
+    end
+    assert_raises(TuxDroid::TuxDroidCommandOptionsError) do
+      tux.send(:validate_within, {:key => 5}, {:key => 1..4})
+    end
+  end
+  
+  #
+  # USB status tests
+  #
+
+  #def test_usb_status
+  #  raise NotImplementedError, 'Need to write test_usb_status'
+  #end
+  
+  private
+  
+  def setup_tux
+    usb_interface = mock()
+    if block_given?
+      yield usb_interface
+    else
+      usb_interface.stubs(:usb_interrupt_write)
+    end
+    TuxDroid::Tux.stubs(:get_usb_device)
+    TuxDroid::Tux.stubs(:get_usb_interface).returns(usb_interface)
+    return TuxDroid::Tux.new
+  end
+  
+  def expect_command(interface, command, param1 = 0, param2 = 0, param3 = 0)
+    bytes = [0]
+    bytes << command
+    bytes << param1.to_i
+    bytes << param2.to_i
+    bytes << param3.to_i
+    interface.expects(:usb_interrupt_write).with(
+      TuxDroid::USBCodes::WRITE_ENDPOINT,
+      bytes.pack('C*'),
+      TuxDroid::USBCodes::WRITE_TIMEOUT
+    )
+  end
+end

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.2
+specification_version: 1
+name: tuxdroid
+version: !ruby/object:Gem::Version 
+  version: 0.1.0
+date: 2007-03-25 00:00:00 +00:00
+summary: A Ruby Command Interface API to the TuxDroid from Kysoh
+require_paths: 
+- lib
+email: ryand-ruby@zenspider.com
+homepage: "    by Andrew Montgomery"
+rubyforge_project: tuxdroid
+description: "== FEATURES/PROBLEMS:  * Simple interface to all basic actions * No sound support yet * No reading the status of any motors or sensors yet  == SYNOPSIS:  require 'tuxdroid' tux = TuxDroid::Tux.new tux.mouth :open tux.mouth :close tux.wings :flap, :times => 2, :speed => 3   == REQUIREMENTS:"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Ryan Davis
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- LICENSE.txt
+- Rakefile
+- lib/tuxdroid.rb
+- lib/tuxdroid/constants.rb
+- test/test_tuxdroid.rb
+test_files: 
+- test/test_tuxdroid.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: