ruby-nxt 0.8.1

data/test/interactive/test_sensors.rb

@@ -0,0 +1,236 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require "commands"
+require "interactive_test_helper"
+
+include InteractiveTestHelper
+
+require "autodetect_nxt"
+
+info "Connecting to the NXT at #{$DEV}..."
+
+begin
+  $nxt = NXTComm.new($DEV)
+rescue
+  fail "Could not connect to the NXT!"
+  fail "The error was: #{$!}"
+  notice "Make sure that the NXT is turned on and that your Bluetooth connection is configured."
+  notice "You may need to change the value of the $DEV variable in #{__FILE__} to point to the correct tty device."
+  exit 1
+end
+
+puts
+
+notice <<NOTE
+Please make sure that all four sensors are plugged in to the standard ports as follows:
+Sensor 1: Touch
+Sensor 2: Sound
+Sensor 3: Light
+Sensor 4: Ultrasonic
+NOTE
+prompt "Press Enter on your keyboard when ready..."
+
+### touch sensor ######
+
+def test_touch_sensor
+  t = Commands::TouchSensor.new($nxt)
+  
+  info "Initializing touch sensor..."
+  t = Commands::TouchSensor.new($nxt)
+  
+  notice "Make sure the touch sensor is NOT pressed..."
+  sleep(2)
+  
+  t.trigger_point = :pressed
+  while t.logic
+  end
+  
+  pass "Touch sensor not pressed!"
+  
+  sleep(2)
+  notice "Now press the touch sensor..."
+  
+  t.trigger_point = :released
+  while t.logic
+  end
+  
+  pass "Touch sensor pressed!"
+  pass "All touch sensor tests passed!"
+  t.off
+  puts
+end
+
+### sound sensor ######
+
+def test_sound_sensor
+  sleep(1)
+  info "Initializing sound sensor..."
+  s = Commands::SoundSensor.new($nxt)
+  
+  sleep(1)
+  notice "Now, be very quiet..."
+  sleep(2)
+  
+  s.comparison = ">"
+  s.trigger_point = 3
+  while s.logic
+    meter(s.sound_level, "Sound Level", 3)
+  end
+  
+  puts
+  pass "OK, sound level was below 3%"
+  
+  sleep(1)
+  notice "Now make some noise!"
+  
+  s.comparison = "<"
+  s.trigger_point = 75
+  while s.logic
+    meter(s.sound_level, "Sound Level", 75)
+  end
+  
+  puts
+  pass "OK, sound level was above 75%"
+  pass "All sound sensor tests passed!"
+  s.off
+  puts
+end
+
+### light sensor ######
+
+def test_light_sensor
+  sleep(1)
+  info "Initializing light sensor..."
+  l = Commands::LightSensor.new($nxt)
+  l.illuminated_mode
+  
+  sleep(1)
+  notice "Put the light sensor up to something white or light coloured..."
+  sleep(1)
+  
+  l.comparison = "<"
+  l.trigger_point = 50
+  while l.logic
+    meter(l.intensity, "Colour", 50)
+  end
+  
+  puts
+  pass "OK, colour lightness was above 50%"
+  
+  sleep(1)
+  notice "Now, put the light sensor up to something black or dark coloured..."
+  sleep(2)
+  
+  l.comparison = ">"
+  l.trigger_point = 20
+  while l.logic
+    meter(l.intensity, "Colour", 20)
+  end
+  
+  puts
+  pass "OK, colour lightness was below 20%"
+  
+  sleep(1)
+  info "Switching to ambient light mode..."
+  l.ambient_mode
+  sleep(1)
+  
+  notice "Now put the light sensor under a lamp or some other bright light source..."
+  sleep(2)
+  
+  l.comparison = "<"
+  l.trigger_point = 65
+  while l.logic
+    meter(l.intensity, "Light", 65)
+  end
+  
+  puts
+  pass "OK, ambient light level was above 65%"
+  
+  sleep(1)
+  notice "Now cover the light sensor with something to block out the light..."
+  sleep(2)
+  
+  l.comparison = ">"
+  l.trigger_point = 15
+  while l.logic
+    meter(l.intensity, "Light", 15)
+  end
+  
+  puts
+  pass "OK, ambient light level was below 15%"
+  pass "All light sensor tests passed!"
+  puts
+  l.off
+end
+
+### ultrasonic sensor ######
+
+def test_ultrasonic_sensor
+  sleep(1)
+  info "Initializing ultrasonic sensor..."
+  us = Commands::UltrasonicSensor.new($nxt)
+  us.mode = :centimeters
+  
+  sleep(1)
+  notice "Point the ultrasonic sensor into the far distance -- at least 2.5 meters (7 feet)..."
+  sleep(2)
+  
+  us.comparison = "<"
+  us.trigger_point = 255
+  
+  while us.logic
+    begin
+      meter(us.distance!, "Distance (cm)", nil, 150, 0)
+    rescue Commands::UltrasonicSensor::UnmeasurableDistance
+      meter(nil, "Distance (cm)", nil, 150, 0)
+    end
+  end
+  puts
+  pass "OK, the sensor says it can't determine the distance (it can't pick up anything over 2 meters away or anything very very close)."
+  
+  sleep(1)
+  notice "Now point the ultrasonic sensor at something less than 8 cm (3 inches) away..."
+  sleep(1)
+  
+  us.comparison = ">"
+  us.trigger_point = 8
+  while us.logic
+    begin
+      meter(us.distance!, "Distance (cm)", 8, 150, 0)
+    rescue Commands::UltrasonicSensor::UnmeasurableDistance
+      meter(nil, "Distance (cm)", 8, 150, 0)
+    end
+  end
+  
+  puts
+  pass "OK, the sensor detected an object 8 cm or less away."
+  
+  sleep(1)
+  notice "Point the ultrasonic sensor at a wall or some other solid object 1 meter (3 feet) or further away..."
+  sleep(1)
+  
+  us.comparison = "<"
+  us.trigger_point = 100
+  while us.logic
+    begin
+      meter(us.distance!, "Distance (cm)", 100, 150, 0)
+    rescue Commands::UltrasonicSensor::UnmeasurableDistance
+      meter(nil, "Distance (cm)", 100, 150, 0)
+    end
+  end
+  
+  puts
+  pass "OK, the sensor detected an object over 1 meter away."
+  pass "All ultrasonic sensor tests passed!"
+  
+  puts
+end
+
+test_touch_sensor
+test_sound_sensor
+test_light_sensor
+test_ultrasonic_sensor
+
+pass "CONGRATULATIONS! ruby-nxt was successfully able to communicate with all of your NXT's sensors."
+
+$nxt.close

data/test/test.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby -w
+
+require "nxt_comm"
+
+# causes ruby-nxt to print out all the bytes sent and received
+$DEBUG = true
+
+@nxt = NXTComm.new('/dev/tty.NXT-DevB-1')
+@nxt.play_tone(500,500)
+
+# command = Commands::Move.new(@nxt)
+# 
+# command.ports = :a
+# command.power = 100
+# command.direction = :backward
+# command.duration = :unlimited
+# 
+# command.start
+# 
+# sleep(3)
+# 
+# command.stop

data/test/test_helper.rb

@@ -0,0 +1 @@
+$: << File.dirname(File.expand_path(__FILE__))+'/../lib'

data/test/unit/motor_test.rb

@@ -0,0 +1,177 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require "test/unit"
+require "motor"
+require "autodetect_nxt"
+
+class MotorTest < Test::Unit::TestCase
+
+  @@nxt = NXTComm.new($DEV)
+  
+  puts "\nWARNING: The battery level is low. Test results may be inconsistent.\n" if @@nxt.get_battery_level < 6040
+
+  def setup
+    @motors = []
+    @motors << Motor.new(@@nxt, :a)
+    @motors << Motor.new(@@nxt, :b)
+    @motors << Motor.new(@@nxt, :c)
+        
+    # make sure that we can talk to each of the motors before we try to run any tests
+#    @motors.each do |m|
+#      state = m.read_state
+#      if not state
+#        raise "Cannot run tests because motor #{m.port} is not responding."
+#      end
+#    end
+  end
+  
+  def teardown
+  end
+  
+  def test_name
+    assert_equal 'a', @motors[0].name
+    assert_equal 'b', @motors[1].name
+    assert_equal 'c', @motors[2].name
+  end
+  
+  def test_read_state
+    # check just one motor
+    state = @motors.first.read_state
+    assert_not_nil state
+    assert_equal @motors.first.port, state[:port]
+  
+    # now do all motors
+    @motors.each do |m|
+      state = m.read_state
+      assert_not_nil state
+      assert_equal m.port, state[:port]
+    end
+    
+    # sanity check... two consecutive state checks should be the same, since nothing's changed
+    @motors.each do |m|
+      state1 = m.read_state
+      state2 = m.read_state
+      assert_equal state1, state2
+    end
+  end
+  
+  def test_reset_tacho
+    @motors.each do |m|
+      m.reset_tacho
+      state = m.read_state
+      assert_equal 0, state[:rotation_count]
+    end
+  end
+  
+  def test_run_by_degrees
+    # we have to use a low power, otherwise we can't get fine tacho control due to inertia
+    
+    @motors.each do |m|
+    	m.stop
+    
+      m.reset_tacho
+      m.forward(:degrees => 180, :power => 5)
+      state = m.read_state
+      assert_in_delta(180, state[:rotation_count], 40)
+      
+      m.stop
+      
+      m.reset_tacho
+      m.backward(:degrees => 180, :power => 5)
+      state = m.read_state
+      assert_in_delta(-180, state[:rotation_count], 40)
+      
+      m.stop
+    end
+  end
+  
+  def test_run_by_seconds
+  	# only need to test one motor, since we already tested tacho for all motors in test_run_by_degrees
+    m = @motors.first
+    
+	  m.reset_tacho
+	  m.forward(:time => 3, :power => 15)
+	  state = m.read_state
+	  assert_in_delta(450, state[:rotation_count], 100)
+	  
+	  m.reset_tacho
+	  m.backward(:time => 3, :power => 15)
+	  state = m.read_state
+	  assert_in_delta(-450, state[:rotation_count], 100)
+  end
+  
+  def test_run_free
+  	m = @motors.first
+  	m.reset_tacho
+  	m.forward(:power => 15)
+  	sleep(3)
+  	m.stop
+  	assert_in_delta(450, m.read_state[:rotation_count], 100)
+  	
+  	# now see what happens when we interrupt the movement
+  	m.reset_tacho
+  	m.forward(:power => 15)
+  	sleep(1)
+  	m.backward(:power => 15)
+  	sleep(1)
+  	m.stop
+  	assert_in_delta(0, m.read_state[:rotation_count], 35)
+  end
+  
+#  def test_tiny_slow_movements
+#  	# it seems to help if we stop for a bit first
+#  	sleep(1)
+#  
+#  	m = @motors.first
+#  	
+#  	m.reset_tacho
+#  	m.forward(:degrees => 10, :power => 1)
+#  	state = m.read_state
+#  	assert_in_delta(10, state[:rotation_count], 2)
+#  
+#  	m.reset_tacho
+#  	m.backward(:degrees => 5, :power => 1)
+#  	state = m.read_state
+#  	assert_in_delta(-5, state[:rotation_count], 2)
+#  	
+#  	m.reset_tacho
+#  	m.forward(:degrees => 5, :power => 1)
+#  	state = m.read_state
+#  	assert_in_delta(5, state[:rotation_count], 2)
+#
+#  	m.reset_tacho
+#  	m.backward(:degrees => 15, :power => 1)
+#  	state = m.read_state
+#  	assert_in_delta(-15, state[:rotation_count], 2)
+#
+#  	
+#  	# Moving by 1 degree pretty much never works :(
+#  	#m.reset_tacho
+#  	#m.forward(:degrees => 1, :power => 1)
+#  	#state = m.read_state
+#  	#assert_equal 1, state[:rotation_count]
+#  end
+  
+# This just doesn't work :(
+#  def test_tiny_fast_movements
+#  	m = @motors.first
+#  	
+#  	m.reset_tacho
+#  	m.forward(:degrees => 10, :power => 100)
+#  	state = m.read_state
+#  	assert_in_delta(10, state[:rotation_count], 3)
+#  
+#  	m.reset_tacho
+#  	m.backward(:degrees => 5, :power => 100)
+#  	state = m.read_state
+#  	assert_in_delta(-5, state[:rotation_count], 3)
+#  	
+#  	# Moving by 1 degree pretty much never works :(
+#  	#m.reset_tacho
+#  	#m.forward(:degrees => 1, :power => 1)
+#  	#state = m.read_state
+#  	#assert_equal 1, state[:rotation_count]
+#  end
+  
+
+  
+end

data/test/unit/nxt_comm_test.rb

@@ -0,0 +1,155 @@
+require File.dirname(__FILE__) + '/../test_helper'
+require "test/unit"
+require "stringio"
+require "nxt_comm"
+
+$DEV = '/dev/tty.NXT-DevB-1'
+
+# Test Setup:
+# * a motor in port A
+# * touch sensor in port 1
+# * the default Try-Touch.rtm program needs to be on the NXT
+
+class NXTCommTest < Test::Unit::TestCase
+
+  @@nxt = NXTComm.new($DEV)
+	
+  def capture_stderr
+    begin
+      $stderr = StringIO.new
+      yield
+      $stderr.rewind && $stderr.read
+    ensure
+      $stderr = STDERR
+    end
+  end
+
+	def test_start_stop_program
+    assert @@nxt.start_program("Try-Touch.rtm")
+    sleep(3)
+    assert @@nxt.stop_program
+	end
+
+  def test_invalid_program_name
+    err = capture_stderr { assert !@@nxt.start_program("foo") }
+    assert_equal "ERROR: Data contains out-of-range values\n", err
+  end
+
+  def test_stop_program_when_nothing_running
+    err = capture_stderr { assert !@@nxt.stop_program }
+    assert_equal "ERROR: No active program\n", err
+  end
+
+  def test_play_sound_file
+    assert @@nxt.play_sound_file("Good Job.rso")
+    sleep(1)
+  end
+
+  def test_invalid_sound_file
+    err = capture_stderr { assert !@@nxt.play_sound_file("foo") }
+    assert_equal "ERROR: Data contains out-of-range values\n", err
+  end
+
+  def test_play_tone
+    assert @@nxt.play_tone(500,300)
+  end
+
+  def test_get_and_set_output
+    assert @@nxt.set_output_state(NXTComm::MOTOR_A,100,NXTComm::MOTORON,NXTComm::REGULATION_MODE_MOTOR_SPEED,100,NXTComm::MOTOR_RUN_STATE_RUNNING,0)
+    state = @@nxt.get_output_state(NXTComm::MOTOR_A)
+    assert_equal 100, state[:power]
+
+    sleep(1)
+
+    assert @@nxt.set_output_state(NXTComm::MOTOR_A,0,NXTComm::BRAKE,NXTComm::REGULATION_MODE_MOTOR_SPEED,0,NXTComm::MOTOR_RUN_STATE_RAMPDOWN,0)
+    state = @@nxt.get_output_state(NXTComm::MOTOR_A)
+    assert_equal 0, state[:power]
+  end
+
+  def test_get_and_set_input
+    assert @@nxt.set_input_mode(NXTComm::SENSOR_1,NXTComm::SWITCH,NXTComm::RAWMODE)
+    values = @@nxt.get_input_values(NXTComm::SENSOR_1)
+    assert_equal 0, values[:mode]
+
+    assert @@nxt.set_input_mode(NXTComm::SENSOR_1,NXTComm::SWITCH,NXTComm::BOOLEANMODE)
+    values = @@nxt.get_input_values(NXTComm::SENSOR_1)
+    assert_equal 32, values[:mode]
+  end
+
+  def test_reset_input_scaled_value
+    assert @@nxt.reset_input_scaled_value(NXTComm::SENSOR_1)
+  end
+
+  def test_message_write
+    err = capture_stderr { assert !@@nxt.message_write(1,"Won't work unless a program is running...") }
+    assert_equal "ERROR: No active program\n", err
+
+    # weird timing problems, can take a while to start a program it seems...
+    sleep(1)
+    assert @@nxt.start_program("Try-Touch.rtm")
+    sleep(3)
+    
+    assert @@nxt.message_write(1,"Chunky Robotic Bacon!")
+    
+    assert @@nxt.stop_program
+  end
+
+  def test_message_read
+    err = capture_stderr { assert !@@nxt.message_read(1) }
+    assert_equal "ERROR: No active program\n", err
+
+    # weird timing problems, can take a while to start a program it seems...
+    sleep(1)
+    assert @@nxt.start_program("Try-Touch.rtm")
+    sleep(3)
+
+    # to properly test message read, I'd need to start a program that places a message in a box...
+    err = capture_stderr { assert !@@nxt.message_read(1) }
+    assert_equal "ERROR: Specified mailbox queue is empty\n", err
+    
+    assert @@nxt.stop_program
+  end
+
+  def test_reset_motor_position
+    assert @@nxt.reset_motor_position(NXTComm::MOTOR_A)
+  end
+
+	def test_get_battery_level
+    result = @@nxt.get_battery_level
+    assert_kind_of Fixnum, result
+    assert result > 0
+	end
+
+  def test_stop_sound_playback
+    assert @@nxt.play_sound_file("Good Job.rso",true)
+    sleep(2)
+    assert @@nxt.stop_sound_playback
+  end
+	
+	def test_keep_alive
+	  assert_equal 600000, @@nxt.keep_alive
+	end
+	
+	def test_get_current_program_name
+    err = capture_stderr { assert !@@nxt.get_current_program_name }
+    assert_equal "ERROR: No active program\n", err
+
+    assert @@nxt.start_program("Try-Touch.rtm")
+    sleep(1)
+    assert_equal "Try-Touch.rtm", @@nxt.get_current_program_name
+    assert @@nxt.stop_program
+	end
+	
+	# TODO write tests for the LS methods, since I'm still not sure what they do, 
+	# I don't know how to test them
+	
+	def test_ls_get_status
+	end
+
+	def test_ls_write
+	end
+	
+	def test_ls_read
+  end
+	
+end