minilab 1.0.0-mswin32

data/lib/minilab_context.rb

@@ -0,0 +1,39 @@
+require 'yaml'
+require 'diy'
+
+class MinilabContext #:nodoc:
+  def build
+    minilab_context = self.class.get_context
+    minilab_context.build_everything
+    minilab_context
+  end
+
+  def self.clear
+    @@context = nil
+  end
+
+  def self.inject(options)
+    object, instance = get_parameters(options)
+
+    get_context[object] = instance
+  end
+  
+  private
+  def self.get_parameters(options)
+    raise "parameters hash was nil" if options.nil?
+    object = options[:object]
+    instance = options[:instance]
+    raise "missing parameter :object" if object.nil?
+    raise "missing parameter :instance" if instance.nil?
+    [object, instance]
+  end
+
+  def self.get_context
+    @@context ||= DIY::Context.new(YAML.load(object_definition))
+    @@context
+  end
+
+  def self.object_definition
+    File.read(APP_ROOT + "/config/objects.yml")
+  end
+end

data/lib/result_verifier.rb

@@ -0,0 +1,14 @@
+require 'constructor'
+
+class ResultVerifier #:nodoc:
+  constructor :minilab_hardware
+
+  def verify(result, user_message="Command")
+    if result[:error]
+      library_message = @minilab_hardware.get_error_string(result[:error])
+      raise "#{user_message} caused a hardware error: #{library_message}"
+    end
+
+    return true
+  end
+end

data/test/integration/analog_input_output_test.rb

@@ -0,0 +1,43 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'integration_test'
+require 'minilab'
+
+class AnalogInputOutputTest < IntegrationTest
+  def setup
+    super
+    build_and_connect_to_minilab
+  end
+
+  should "read analog data" do
+    for_all_input_channels do |channel|
+      @minilab_hardware.expects.read_analog(channel).returns(no_error_and_value(3.22))
+    end
+
+    for_all_input_channels do |channel|
+      assert_equal 3.22, @minilab.read_analog(channel), "wrong value analog value read"
+    end
+  end
+
+  should "write analog data" do
+    for_all_output_channels do |channel|
+      @minilab_hardware.expects.write_analog(channel, 1.78).returns(no_error)
+    end
+
+    for_all_output_channels do |channel|
+      assert @minilab.write_analog(channel, 1.78)
+    end
+  end
+
+  private
+  def for_all_input_channels
+    0.upto(7) do |channel|
+      yield channel
+    end
+  end
+
+  def for_all_output_channels
+    0.upto(1) do |channel|
+      yield channel
+    end
+  end
+end

data/test/integration/connect_to_hardware_test.rb

@@ -0,0 +1,13 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'integration_test'
+require 'minilab'
+
+class ConnectToHardwareTest < IntegrationTest
+  def setup
+    super
+  end
+
+  should "setup error handling, declare the library revision, and setup each digital port for input when connecting" do
+    build_and_connect_to_minilab
+  end
+end

data/test/integration/digital_input_output_test.rb

@@ -0,0 +1,114 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'integration_test'
+require 'minilab'
+
+class DigitalInputOutputTest < IntegrationTest
+  def setup
+    super
+    build_and_connect_to_minilab
+  end
+
+  should "read digital data from the terminals on the top of the device" do
+    for_all_screw_terminals do |terminal|
+      terminal_number = get_terminal_number(terminal)
+      configuration = { :direction => DIGITALIN, :pin => terminal_number }
+      @minilab_hardware.expects.configure_auxport(configuration).returns(no_error)
+      @minilab_hardware.expects.read_auxport(terminal_number).returns(no_error_and_value(1))
+    end
+
+    for_all_screw_terminals do |terminal|
+      assert_equal 1, @minilab.read_digital(terminal)
+    end
+  end
+
+  should "write digital data to the terminals" do
+    for_all_screw_terminals do |terminal|
+      terminal_number = get_terminal_number(terminal)
+      configuration = { :direction => DIGITALOUT, :pin => terminal_number }
+      @minilab_hardware.expects.configure_auxport(configuration).returns(no_error)
+      @minilab_hardware.expects.write_auxport(terminal_number, 0).returns(no_error)
+    end
+
+    for_all_screw_terminals do |terminal|
+      assert @minilab.write_digital(terminal, 0)
+    end
+  end
+
+  should "read digital data from the external digital pins only if the port is configured for input" do
+    configure_each_port_for_input
+
+    # We'll go with just one pin for each of the four ports.
+    # Finer grained testing of each pin is left to the unit tests.
+    for_some_digital_pins do |numbered_pin, library_pin|
+      @minilab_hardware.expects.read_digital_pin(library_pin).returns(no_error_and_value(0))
+      assert_equal 0, @minilab.read_digital(numbered_pin), "wrong value"
+    end
+  end
+
+  should "raise an error when there is a problem reading a digital pin" do
+    configure_each_port_for_input
+    for_some_digital_pins do |numbered_pin, library_pin|
+      @minilab_hardware.expects.read_digital_pin(library_pin).returns(error(2))
+      expect_get_error_string :error => 2, :message => "yoink"
+      assert_error(RuntimeError, /yoink/) { @minilab.read_digital(numbered_pin) }
+    end
+  end
+
+  should "write digital data to the external digital pins only if the port is configured for output" do
+    configure_each_port_for_output
+
+    for_some_digital_pins do |numbered_pin, library_pin|
+      @minilab_hardware.expects.write_digital_pin(library_pin, 1).returns(no_error)
+      assert @minilab.write_digital(numbered_pin, 1), "should have written with no error"
+    end
+  end
+
+  should "read an entire byte from a single port only if the port is configured for input" do
+    configure_each_port_for_input
+    @port_to_library_port_mapping.each do |port, library_port|
+      @minilab_hardware.expects.read_port(library_port).returns(no_error_and_value(167))
+      assert_equal 167, @minilab.read_digital_byte(port), "read wrong value"
+    end
+  end
+
+  private
+  def get_terminal_number(terminal)
+    terminal[-1..-1].to_i
+  end
+
+  def for_some_digital_pins
+    # The pins numbered on the external ports don't match what the
+    # minilab library uses. The ruby code is responsible for doing the
+    # correct translation.
+    {
+      32 => 5,
+      6 => 12,
+      26 => 19,
+      25 => 20
+    }.each do |numbered_pin, library_pin|
+      yield numbered_pin, library_pin
+    end
+  end
+
+  def for_all_screw_terminals
+    ['DIO0', 'DIO1', 'DIO2', 'DIO3'].each do |terminal|
+      yield terminal
+    end
+  end
+
+  def configure_each_port_for_input
+    @port_to_library_port_mapping.each do |port, library_port|
+      expected_configuration = { :direction => DIGITALIN, :port => library_port }
+      @minilab_hardware.expects.configure_port(expected_configuration).returns(no_error)
+      @minilab.configure_input_port(port)
+    end
+  end
+
+  def configure_each_port_for_output
+    @port_to_library_port_mapping.each do |port, library_port|
+      expected_configuration = { :direction => DIGITALOUT, :port => library_port }
+      @minilab_hardware.expects.configure_port(expected_configuration).returns(no_error)
+      @minilab.configure_output_port(port)
+    end
+  end
+end

data/test/integration/integration_test.rb

@@ -0,0 +1,53 @@
+require 'minilab_context'
+require 'extension/minilab_hardware'
+
+class IntegrationTest < Test::Unit::TestCase
+  include MinilabConstants
+
+  def setup
+    MinilabContext.clear
+    create_mock :minilab_hardware
+    MinilabContext.inject :object => :minilab_hardware, :instance => @minilab_hardware
+
+    @port_to_library_port_mapping = {
+      :porta => FIRSTPORTA,
+      :portb => FIRSTPORTB,
+      :portcl => FIRSTPORTCL,
+      :portch => FIRSTPORTCH
+    }
+  end
+
+  def no_error
+    {:no => :error}
+  end
+
+  def error(number)
+    {:error => number}
+  end
+
+  def no_error_and_value(value)
+    {:no => :error, :value => value}
+  end
+
+  def expect_get_error_string(optz)
+    @minilab_hardware.expects.get_error_string(optz[:error]).returns(optz[:message])
+  end
+
+  def build_and_connect_to_minilab
+    @minilab = Minilab.build
+
+    @minilab_hardware.expects.setup_error_handling(DONTPRINT, STOPALL).returns(no_error)
+    @minilab_hardware.expects.declare_revision(CURRENTREVNUM).returns(no_error)
+
+    configure_input_result = {:no => :error}
+    [:porta, :portb, :portcl, :portch].each do |port|
+      expected_configuration = { :direction => DIGITALIN, :port => @port_to_library_port_mapping[port] }
+      @minilab_hardware.expects.configure_port(expected_configuration).returns(no_error)
+    end
+
+    @minilab.connect
+  end
+
+  should "have an empty test case so that Test::Unit::TestCase doesn't complain" do
+  end
+end

data/test/integration/require_minilab_test.rb

@@ -0,0 +1,9 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../test_helper"
+require 'integration_test'
+
+class RequireMinilabTest < IntegrationTest
+  should "be able to require the minilab class without error" do
+    `ruby -e "require 'lib/minilab'"`
+    assert $?.success?, "failed to require minilab without error"
+  end
+end

data/test/system/analog_input.test

@@ -0,0 +1,3 @@
+analog_input_4_should_be_about 5.0
+
+analog_input_1_should_be_about 0.0

data/test/system/analog_output.test

@@ -0,0 +1,37 @@
+# The sleeps are required, as it takes time for the
+# commanded voltages to reach the desired value
+
+# test analog output 1
+write_analog_1 5.0
+sleep 0.1
+analog_input_0_should_be_about 5.0
+
+write_analog_1 0.0
+sleep 0.1
+analog_input_0_should_be_about 0.0
+
+write_analog_1 2.77
+sleep 0.1
+analog_input_0_should_be_about 2.77
+
+write_analog_1 3.19
+sleep 0.1
+analog_input_0_should_be_about 3.19
+
+# test analog output 0
+write_analog_0 5.0
+sleep 0.1
+analog_input_6_should_be_about 5.0
+
+write_analog_0 0.0
+sleep 0.1
+analog_input_6_should_be_about 0.0
+
+write_analog_0 3.75
+sleep 0.1
+analog_input_6_should_be_about 3.75
+
+write_analog_0 1.88
+sleep 0.1
+analog_input_6_should_be_about 1.88
+

data/test/system/digital_port_input.test

@@ -0,0 +1,5 @@
+configure_portb_for_input
+digital_pin_10_should_be 1
+
+configure_porta_for_input
+digital_pin_30_should_be 0

data/test/system/digital_port_output.test

@@ -0,0 +1,39 @@
+# Port A --> Port B test
+configure_porta_for_output
+configure_portb_for_input
+
+write_digital_pin_36 1
+digital_pin_7_should_be 1
+
+write_digital_pin_36 0
+digital_pin_7_should_be 0
+
+# Port B --> Port CL test
+configure_portb_for_output
+configure_portcl_for_input
+
+write_digital_pin_5 0
+digital_pin_28_should_be 0
+
+write_digital_pin_5 1
+digital_pin_28_should_be 1
+
+# Port CL -> Port CH test
+configure_portcl_for_output
+configure_portch_for_input
+
+write_digital_pin_27 1
+digital_pin_22_should_be 1
+
+write_digital_pin_27 0
+digital_pin_22_should_be 0
+
+# Port CH -> Port A test
+configure_portch_for_output
+configure_porta_for_input
+
+write_digital_pin_24 0
+digital_pin_34_should_be 0
+
+write_digital_pin_24 1
+digital_pin_34_should_be 1

data/test/system/digital_port_read_byte.test

@@ -0,0 +1,26 @@
+configure_porta_for_output
+configure_portcl_for_output
+configure_portb_for_input
+
+                       # GND to pin 3 (portb bit 7)
+                       # GND to pin 4 (portb bit 6)
+write_digital_pin_28 1 # map to pin 5 (portb bit 5)
+                       # GND to pin 6 (portb bit 4)
+write_digital_pin_36 1 # map to pin 7 (portb bit 3)
+                       # GND to pin 8 (portb bit 2)
+                       # GND to pin 9 (portb bit 1)
+                       # +5v to pin 10 (portb bit 0)
+digital_portb_should_be 0x29
+
+
+
+configure_porta_for_output
+configure_portcl_for_output
+configure_portch_for_input
+
+write_digital_pin_27 1 # map to pin 22 (portch bit 3)
+                       # GND to pin 23 (portch bit 2)
+write_digital_pin_32 1 # map to pin 24 (portch bit 1)
+                       # GND to pin 22 (portch bit 0)
+digital_portch_should_be 0x0A
+

data/test/system/digital_screw_terminals_input.test

@@ -0,0 +1,2 @@
+DIO1_should_be 1
+DIO2_should_be 0

data/test/system/digital_screw_terminals_output.test

@@ -0,0 +1,11 @@
+write_DIO0 1
+DIO3_should_be 1
+
+write_DIO0 0
+DIO3_should_be 0
+
+write_DIO0 0
+analog_input_2_should_be_about 0.0
+
+write_DIO0 1
+analog_input_2_should_be_greater_than 0.0

data/test/system/minilab_driver.rb

@@ -0,0 +1,85 @@
+require 'systir'
+require 'minilab'
+
+class MinilabDriver < Systir::LanguageDriver
+  GOOD_DELTA = 0.12
+  VALID_PORTS = [:porta, :portb, :portcl, :portch]
+  VALID_PINS = (30..37).to_a + (3..10).to_a + (26..29).to_a + (22..25).to_a
+
+  def setup
+    @minilab = Minilab.build
+    @minilab.connect
+  end
+
+  # Analog input methods
+  0.upto(7) do |channel|
+    define_method("analog_input_#{channel}_should_be_about") do |value|
+      expect_read_analog(channel, value)
+    end
+
+    define_method("analog_input_#{channel}_should_be_greater_than") do |value|
+      volts = @minilab.read_analog(channel)
+      assert volts > (value + GOOD_DELTA)
+    end
+  end
+
+  # Analog output methods
+  [0, 1].each do |channel|
+    define_method("write_analog_#{channel}") do |value|
+      @minilab.write_analog(channel, value)
+    end
+  end
+
+  # DIOx input and output methods
+  0.upto(3) do |pin|
+    define_method("DIO#{pin}_should_be") do |value|
+      assert_equal value, @minilab.read_digital("DIO#{pin}")
+    end
+
+    define_method("write_DIO#{pin}") do |value|
+      @minilab.write_digital("DIO#{pin}", value)
+    end
+  end
+  
+  # Digital pin input and output methods
+  VALID_PINS.each do |pin|
+    define_method("digital_pin_#{pin}_should_be") do |value|
+      assert_equal value, @minilab.read_digital(pin)
+    end
+
+    define_method("write_digital_pin_#{pin}") do |value|
+      @minilab.write_digital(pin, value)
+    end
+  end
+
+  # Digital port read (entire bytes) methods
+  VALID_PORTS.each do |port|
+    define_method("digital_#{port}_should_be") do |value|
+      assert_equal value, @minilab.read_digital_byte(port)
+    end
+  end
+
+  # Configuration methods
+  VALID_PORTS.each do |port|
+    define_method("configure_#{port}_for_input") do
+      @minilab.configure_input_port(port)
+    end
+    
+    define_method("configure_#{port}_for_output") do
+      @minilab.configure_output_port(port)
+    end
+  end
+
+  # Other
+  def minilab_revision_should_be(revision)
+    assert_equal revision, @minilab.get_revision
+  end
+
+  private
+  def expect_read_analog(channel, volts)
+    input = @minilab.read_analog(channel)
+
+    assert_in_delta(volts, input, GOOD_DELTA,
+      "Input voltage was not ~#{volts} volts")
+  end
+end