nxt 0.2.0 → 0.3.0

data/lib/nxt.rb

@@ -7,6 +7,7 @@ require 'nxt/utils/accessors'
 require 'nxt/patches/module'
 
 require 'nxt/exceptions'
+require 'nxt/errors'
 
 require 'nxt/interfaces/base'
 require 'nxt/interfaces/usb'

data/lib/nxt/commands/base.rb

@@ -1,6 +1,7 @@
 module NXT
   module Command
     module Base
+
       private
 
       COMMAND_TYPES = {
@@ -9,6 +10,28 @@ module NXT
         reply: 0x02
       }.freeze
 
+      COMMANDS = {
+        0x00 => 'startprogram',
+        0x01 => 'stopprogram',
+        0x02 => 'playsoundfile',
+        0x03 => 'playtone',
+        0x04 => 'setoutputstate',
+        0x05 => 'setinputmode',
+        0x06 => 'getoutputstate',
+        0x07 => 'getinputvalues',
+        0x08 => 'resetinputscaledvalue',
+        0x09 => 'messagewrite',
+        0x0a => 'resetmotorposition',
+        0x0b => 'getbatterylevel',
+        0x0c => 'stopsoundplayback',
+        0x0d => 'keepalive',
+        0x0e => 'lsgetstatus',
+        0x0f => 'lswrite',
+        0x10 => 'lsread',
+        0x11 => 'getcurrentprogramname',
+        0x13 => 'messageread',
+      }
+
       PORTS = {
         a: 0x00,
         b: 0x01,

data/lib/nxt/commands/input.rb

@@ -0,0 +1,60 @@
+module NXT
+  module Command
+    module Input
+      include NXT::Command::Base
+      extend NXT::Utils::Accessors
+
+      @@command_type = COMMAND_TYPES[:direct]
+      @@command = 0x05
+
+      SENSOR_TYPES = {}
+      [:no_sensor,
+       :switch,
+       :temperature,
+       :reflection,
+       :angle,
+       :light_active,
+       :light_inactive,
+       :sound_db,
+       :sound_dba,
+       :custom,
+       :lowspeed,
+       :lowspeed_9v,
+       :highspeed,
+       :colorfull,
+       :colorred,
+       :colorgreen,
+       :colorblue,
+       :colornone
+      ].each_with_index do |key, index|
+        SENSOR_TYPES[key] = index
+      end
+
+      SENSOR_MODES = {
+        :rawmode => 0x00,
+        :booleanmode => 0x20,
+        :transitioncntmode => 0x40,
+        :periodcountermode => 0x60,
+        :pctfullscalemode => 0x80,
+        :celsiusmode => 0xA0,
+        :fahrenheitmode => 0xC0,
+        :anglestepmode => 0xE0,
+        :slopemask => 0x1F,
+        :modemask => 0xE0
+      }
+
+      def set_input_mode(type, mode)
+        raise "Invalid sensor type: #{type}" if !type.nil? && !SENSOR_TYPES.include?(type)
+
+        @interface.send_and_receive([
+          @@command_type,
+          @@command,
+          port_as_byte(@port),
+          SENSOR_TYPES[type],
+          SENSOR_MODES[mode]
+        ])
+      end
+    end
+  end
+end
+

data/lib/nxt/commands/program.rb

@@ -0,0 +1,70 @@
+module NXT
+  module Command
+    module Output
+      class Program
+        include NXT::Command::Base
+
+        @@command_type = COMMAND_TYPES[:direct]
+        START_PROGRAM = 0x00
+        STOP_PROGRAM = 0x01
+        GET_CURRENT_PROGRAM_NAME = 0x11
+
+        def initialize(interface, name=nil)
+          @interface = interface
+          @name = name
+        end
+
+        def start
+          self.class.start(@interface, @name)
+        end
+
+        def stop
+          self.class.stop(@interface)
+        end
+
+
+        class << self
+
+          def start(interface, name)
+            response = send_command(interface, START_PROGRAM, name)
+
+            unless response[:status] == NXT::Errors::SUCCESS
+              message = "#{response[:message]}; Try using '.rxe' as the filename extension"
+              raise NXT::Exceptions::CommandError.new message
+            end
+
+            response
+          end
+
+          def stop(interface)
+            send_command(interface, STOP_PROGRAM)
+          end
+
+          def get_running_name(interface)
+            response = send_command(interface, GET_CURRENT_PROGRAM_NAME)
+            raise NXT::Exceptions::CommandError.new(response[:message]) if response[:status] != NXT::Errors::SUCCESS
+            convert_data_to_string(response[:data])
+          end
+
+          private
+          def send_command(interface, command, name=nil)
+
+            array = [@@command_type, command]
+            array.concat convert_string_to_data(name) unless name.nil?
+
+            response = interface.send_and_receive(array)
+          end
+
+          def convert_data_to_string(data)
+            data.pack("C*").strip
+          end
+
+          def convert_string_to_data(name, max_length=20)
+            name.ljust(max_length, "\0").unpack("C*")
+          end
+        end
+      end
+    end
+  end
+end
+

data/lib/nxt/connectors/base.rb

@@ -0,0 +1,35 @@
+module NXT
+  module Connector
+    module Base
+      SENSOR_TYPES = {}
+      [:no_sensor,
+       :switch,
+       :temperature,
+       :reflection,
+       :angle,
+       :light_active,
+       :light_inactive,
+       :sound_db,
+       :sound_dba,
+       :custom,
+       :lowspeed,
+       :lowspeed_9v,
+       :highspeed,
+       :colorfull,
+       :colorred,
+       :colorgreen,
+       :colorblue,
+       :colornone
+      ].each_with_index do |key, index|
+        SENSOR_TYPES[key] = index
+      end
+
+      def set_input_mode(interface, type, mode)
+        raise "Invalid sensor type: #{mode}" if !mode.nil? && !SENSOR_TYPES.include?(mode)
+
+
+      end
+    end
+  end
+end
+

data/lib/nxt/connectors/input/color.rb

@@ -2,9 +2,28 @@ module NXT
   module Connector
     module Input
       class Color
-        def initialize(port)
+        include NXT::Command::Input
+
+        attr_accessor :port, :interface
+
+        COLORS = {
+          :off => :colornone,
+          :red => :colorred,
+          :green => :colorgreen,
+          :blue => :colorblue,
+          :all => :colorfull
+        }
+        def initialize(port, interface)
+          @interface = interface
           @port = port
         end
+
+        def set_color(color)
+          raise "Invalid color #{color}" unless COLORS.include?(color)
+
+          set_input_mode(COLORS[color], :booleanmode)
+
+        end
       end
     end
   end

data/lib/nxt/connectors/output/motor.rb

@@ -13,10 +13,12 @@ module NXT
 
         attr_combined_accessor :duration, 0
         attr_combined_accessor :duration_type, :seconds
-        attr_combined_accessor :duration_after, :stop
+        attr_combined_accessor :duration_after, :brake
         attr_combined_accessor :direction, :forwards
 
-        attr_setter :direction, is_key_in: DIRECTION
+        attr_setter :direction, is_in: DIRECTION
+        attr_setter :duration_after, is_in: DURATION_AFTER
+        attr_setter :duration_type, is_in: DURATION_TYPE
 
         def initialize(port, interface)
           @port = port
@@ -27,39 +29,11 @@ module NXT
           raise TypeError.new('Expected duration to be a number') unless duration.is_a?(Integer)
           @duration = duration
 
-          if options.include?(:type)
-            type = options[:type]
-
-            unless DURATION_TYPE.include?(type)
-              raise TypeError.new("Expected duration type to be one of: :#{DURATION_TYPE.join(', :')}")
-            end
-
-            @duration_type = type
-          else
-            @duration_type = :seconds
-          end
+          self.duration_type = options[:type] if options.include?(:type)
 
           if options.include?(:after)
-            if @duration_type == :seconds
-              after = options[:after]
-
-              unless DURATION_AFTER.include?(after)
-                raise TypeError.new("Expected after option to be one of: :#{DURATION_AFTER.join(', :')}")
-              end
-
-              @duration_after = after
-            else
-              raise TypeError.new('The after option is only available when the unit duration is in seconds.')
-            end
-          else
-            @duration_after = :stop
-          end
-
-          case @duration_type
-          when :rotations
-            self.tacho_limit = @duration * 360
-          when :degrees
-            self.tacho_limit = @duration
+            raise TypeError.new('The after option is only available when the unit duration is in seconds.') if self.duration_type != :seconds
+            self.duration_after = options[:after]
           end
 
           self
@@ -84,13 +58,9 @@ module NXT
 
         # takes block for response, or can return the response instead.
         def move
-          response_required = false
-
-          if self.duration > 0 && self.duration_type != :seconds
-            response_required = true
-          end
+          response_required = (self.duration > 0 && self.duration_type != :seconds)
 
-          set_output_state(response_required)
+          set_motor_output_state(response_required)
 
           if self.duration > 0 && self.duration_type == :seconds
             sleep(self.duration)
@@ -110,16 +80,34 @@ module NXT
           self.run_state = :running
           self.tacho_limit = 0
         end
-      end
 
-      # overrides
-      def set_output_state(response_required=true)
-        original_power = self.power
-        self.power *= -1 if self.direction == :backwards
 
-        super
+        private
+        def set_motor_output_state(response_required=true)
+          original_tacho_limit = self.tacho_limit
+          adjust_tacho_limit
+
+          original_power = self.power
+          adjust_power
+
+          set_output_state(response_required)
+
+          self.power = original_power
+          self.tacho_limit = original_tacho_limit
+        end
 
-        self.power = original_power
+        def adjust_tacho_limit
+          case self.duration_type
+          when :rotations
+            self.tacho_limit = self.duration * 360
+          when :degrees
+            self.tacho_limit = self.duration
+          end
+        end
+
+        def adjust_power
+          self.power *= -1 if self.direction == :backwards
+        end
       end
     end
   end

data/lib/nxt/errors.rb

@@ -0,0 +1,25 @@
+module NXT
+  module Errors
+    SUCCESS = 0x00
+    CODES = {
+      SUCCESS => 'Success',
+      0x20 => 'Pending communication transaction in progress',
+      0x40 => 'Specified mailbox queue is empty',
+      0xBD => 'Request failed (i.e., specified file not found)',
+      0xBE => 'Unknown command opcode',
+      0xBF => 'Insane packet',
+      0xC0 => 'Data contains out-of-range values',
+      0xDD => 'Communication bus error',
+      0xDE => 'No free memory in communication buffer',
+      0xDF => 'Specified channel/connection is not valid',
+      0xE0 => 'Specified channel/connection not configured or busy',
+      0xEC => 'No active program',
+      0xED => 'Illegal size specified',
+      0xEE => 'Illegal mailbox queue ID specified',
+      0xEF => 'Attempted to access invalid field of a structure',
+      0xF0 => 'Bad input or output specified',
+      0xFB => 'Insufficient memory available',
+      0xFF => 'Bad arguments'
+    }
+  end
+end

data/lib/nxt/exceptions.rb

@@ -19,5 +19,8 @@ module NXT
 
     # Raised when communication with a Serial Port connection fails.
     class SerialPortConnectionError < RuntimeError; end
+
+    # Raised when a command returns a reply message error
+    class CommandError < RuntimeError; end
   end
 end

data/lib/nxt/interfaces/base.rb

@@ -1,9 +1,11 @@
+require_relative '../commands/base' #TODO: bad code smell here
+
 module NXT
   module Interface
     class Base
       def send_and_receive(msg, response_required = true)
         if response_required
-          msg[0] = msg[0] | (response_required ? 0x80 : 0x00)
+          msg[0] = msg[0] | (response_required ? 0x00 : 0x80)
         end
 
         self.send(msg)

data/lib/nxt/interfaces/serial_port.rb

@@ -69,7 +69,19 @@ module NXT
         #
         # Reference: Appendix 1, Page 22
         length = @connection.sysread(2)
-        @connection.sysread(length.unpack('v')[0])
+        actual_length = length.unpack('v')[0]
+        response_bytes = @connection.sysread(actual_length)
+        response_array = response_bytes.unpack('C*')
+        response = {
+          :reply => response_array[0] == 0x02,
+          :for_command => response_array[1],
+          :status => response_array[2]
+        }
+        response[:message] = NXT::Errors::CODES[response[:status]]
+        response[:for_command_name] = NXT::Command::Base::COMMANDS[response[:for_command]]
+        response[:data] = response_array[3..-1] if response_array.size > 3
+
+        response
       end
     end
   end

data/lib/nxt/nxt_brick.rb

@@ -146,6 +146,18 @@ class NXTBrick
     end
   end
 
+  def start_program(name)
+    NXT::Command::Output::Program.start(self.interface, name)
+  end
+
+  def stop_program
+    NXT::Command::Output::Program.stop(self.interface)
+  end
+
+  def running_program_name
+    NXT::Command::Output::Program.get_running_name(self.interface)
+  end
+
   private
   def validate_interface(interface_type_name_string)
     unless NXT::Interface.constants.include?(interface_type_name_string.to_sym)

data/lib/nxt/utils/accessors.rb

@@ -4,11 +4,15 @@ module NXT
       def attr_setter(name, options)
         define_method("#{name}=") do |value|
           if options.include?(:is)
-            raise TypeError.new('Expected value to be a number') unless duration.is_a?(options[:is])
+            raise TypeError.new('Expected value to be a #{options[:is]}') unless duration.is_a?(options[:is])
           end
 
-          if options.include?(:is_key_in) && !options[:is_key_in].include?(value)
-            raise TypeError.new("Expected value to be one of: :#{options[:is_key_in].keys.join(', :')}")
+          if options.include?(:is_in)
+            raise TypeError.new("Expected value to be one of: #{options[:is_in].join(', ')}") unless options[:is_in].include?(value)
+          end
+
+          if options.include?(:is_key_in)
+            raise TypeError.new("Expected value to be one of: :#{options[:is_key_in].keys.join(', :')}") unless options[:is_key_in].include?(value)
           end
 
           instance_variable_set("@#{name}", value)

data/spec/nxt/connectors/output/motor_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+describe NXT::Connector::Output::Motor do
+
+  subject do
+    NXT::Connector::Output::Motor.new(nil, nil)
+  end
+
+  context '#duration' do
+    # TODO: Should be OK to use any number, but documenting current behavior
+    it 'should not allow a non-Integer duration' do
+      expect do
+        subject.duration(0.5)
+      end.to raise_exception(TypeError)
+    end
+
+    it 'should allow valid type options' do
+      subject.duration(1, :type => :rotations)
+      subject.duration(1, :type => :seconds)
+      subject.duration(1, :type => :degrees)
+    end
+
+    it 'should not allow invalid type option' do
+      expect do
+        subject.duration(1, :type => :incorrect_duration_after_type)
+      end.to raise_exception(TypeError)
+    end
+
+    it 'should default to seconds as the duration unit' do
+      subject.duration(1)
+
+      subject.duration_type.should == :seconds
+    end
+
+    context "setting the :after option" do
+      # TODO: This isn't right...should change this
+      # but I'm just documenting current behavior
+      it 'should prevent using the :after option unless duration_type is :seconds' do
+        expect do
+          subject.duration(1, :type => :rotations, :after => :coast)
+        end.to raise_exception(TypeError)
+      end
+
+      it 'should allow using the :afer option when the duration type is :seconds' do
+        subject.duration(1, :type => :seconds, :after => :coast)
+      end
+
+      it 'should not allow setting an invalid value' do
+        expect do
+          subject.duration(1, :type => :seconds, :after => :foobar)
+        end.to raise_exception(TypeError)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: nxt
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-03 00:00:00.000000000 Z
+date: 2013-03-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serialport
@@ -124,7 +124,7 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: 2.1.0
-description: Control an NXT 2.0 See http://github.com/nathankleyn/nxt for more information.
+description: Control an NXT 2.0 See http://github.com/tchype/ruby-nxt for more information.
 email: tony@heupel.org
 executables: []
 extensions: []
@@ -139,10 +139,12 @@ files:
 - lib/nxt/commands/program.rb
 - lib/nxt/commands/sound.rb
 - lib/nxt/commands/tone.rb
+- lib/nxt/connectors/base.rb
 - lib/nxt/connectors/input/color.rb
 - lib/nxt/connectors/input/touch.rb
 - lib/nxt/connectors/input/ultrasonic.rb
 - lib/nxt/connectors/output/motor.rb
+- lib/nxt/errors.rb
 - lib/nxt/exceptions.rb
 - lib/nxt/interfaces/base.rb
 - lib/nxt/interfaces/serial_port.rb
@@ -153,10 +155,11 @@ files:
 - lib/nxt/utils/accessors.rb
 - lib/nxt.rb
 - spec/matchers.rb
+- spec/nxt/connectors/output/motor_spec.rb
 - spec/nxt/interfaces/serial_port_spec.rb
 - spec/nxt/nxt_brick_spec.rb
 - spec/spec_helper.rb
-homepage: http://github.com/tchype/nxt
+homepage: http://github.com/tchype/ruby-nxt
 licenses: []
 post_install_message: 
 rdoc_options: []