minilab 2.0.0-x86-mingw32

data/lib/minilab/minilab_hardware.rb

@@ -0,0 +1,118 @@
+require "ffi"
+require "pathname"
+
+module Minilab
+  class MinilabHardware
+    include MinilabConstants
+
+    def setup_error_handling(reporting, handling)
+      create_error_hash cbErrHandling(reporting, handling)
+    end
+
+    def declare_revision(revision)
+      memory = FFI::MemoryPointer.new :float
+      memory.write_float(revision)
+      create_error_hash cbDeclareRevision(memory)
+    end
+
+    def get_revision
+      dll_revision_number = FFI::MemoryPointer.new :float
+      vxd_revision_number = FFI::MemoryPointer.new :float
+      error = cbGetRevision(dll_revision_number, vxd_revision_number)
+      create_error_or_value_hash(error, dll_revision_number.read_float)
+    end
+
+    def get_error_string(error)
+      message = FFI::MemoryPointer.new :char, ERRSTRLEN
+      new_error = cbGetErrMsg(error, message)
+      if new_error != 0
+        create_error_hash(new_error)
+      else
+        message.read_string
+      end
+    end
+
+    def configure_auxport(optz)
+      raise ":pin is a required parameter" if optz[:pin].nil?
+      raise ":direction is a required parameter" if optz[:direction].nil?
+      create_error_hash cbDConfigBit(BOARDNUM, AUXPORT, optz[:pin], optz[:direction])
+    end
+
+    def configure_port(optz)
+      raise ":port is a required parameter" if optz[:port].nil?
+      raise ":direction is a required parameter" if optz[:direction].nil?
+      create_error_hash cbDConfigPort(BOARDNUM, optz[:port], optz[:direction])
+    end
+
+    def read_analog(channel)
+      raw_data = FFI::MemoryPointer.new :ushort
+      error = cbAIn(BOARDNUM, channel, BIP10VOLTS, raw_data)
+      return create_error_hash(error) if error != 0
+
+      voltage = FFI::MemoryPointer.new :float
+      error = cbToEngUnits(BOARDNUM, BIP10VOLTS, raw_data.get_ushort(0), voltage)
+      create_error_or_value_hash(error, voltage.read_float)
+    end
+
+    def read_digital_pin(pin)
+      data = FFI::MemoryPointer.new :ushort
+      error = cbDBitIn(BOARDNUM, FIRSTPORTA, pin, data)
+      create_error_or_value_hash(error, data.get_ushort(0))
+    end
+
+    def read_auxport(pin)
+      data = FFI::MemoryPointer.new :ushort
+      error = cbDBitIn(BOARDNUM, AUXPORT, pin, data)
+      create_error_or_value_hash(error, data.get_ushort(0))
+    end
+
+    def read_port(port)
+      data = FFI::MemoryPointer.new :ushort
+      error = cbDIn(BOARDNUM, port, data)
+      create_error_or_value_hash(error, data.get_ushort(0))
+    end
+
+    def write_analog(channel, volts)
+      raw_data = FFI::MemoryPointer.new :ushort
+      error = cbFromEngUnits(BOARDNUM, UNI5VOLTS, volts, raw_data)
+      return create_error_hash(error) if error != 0
+      error = cbAOut(BOARDNUM, channel, UNI5VOLTS, raw_data.get_ushort(0))
+      create_error_hash(error)
+    end
+
+    def write_digital_pin(pin, data)
+      create_error_hash cbDBitOut(BOARDNUM, FIRSTPORTA, pin, data)
+    end
+
+    def write_auxport(pin, data)
+      create_error_hash cbDBitOut(BOARDNUM, AUXPORT, pin, data)
+    end
+
+    private
+    def create_error_or_value_hash(error, value)
+      error != 0 ? { :error => error } : { :value => value }
+    end
+
+    def create_error_hash(error)
+      create_error_or_value_hash(error, true)
+    end
+
+    MCC_LIBRARY = Pathname.new(__FILE__).dirname.join("..", "..", "vendor", "mcc", "cbw32.dll")
+    extend FFI::Library
+    ffi_lib MCC_LIBRARY
+
+    attach_function "cbErrHandling", [:int, :int], :int
+    attach_function "cbDeclareRevision", [:pointer], :int
+    attach_function "cbGetRevision", [:pointer, :pointer], :int
+    attach_function "cbGetErrMsg", [:int, :pointer], :int
+    attach_function "cbDConfigBit", [:int, :int, :int, :int], :int
+    attach_function "cbDConfigPort", [:int, :int, :int], :int
+    attach_function "cbAIn", [:int, :int, :int, :pointer], :int
+    attach_function "cbToEngUnits", [:int, :int, :ushort, :pointer], :int
+    attach_function "cbFromEngUnits", [:int, :int, :float, :pointer], :int
+    attach_function "cbDBitIn", [:int, :int, :int, :pointer], :int
+    attach_function "cbDIn", [:int, :int, :pointer], :int
+    attach_function "cbAOut", [:int, :int, :int, :ushort], :int
+    attach_function "cbDBitOut", [:int, :int, :int, :ushort], :int
+  end
+end

data/lib/minilab/minilab_wrapper.rb

@@ -0,0 +1,14 @@
+module Minilab
+  class MinilabWrapper #:nodoc:
+    constructor :minilab_hardware
+
+    def method_missing(method, *argz)
+      result = @minilab_hardware.send(method, *argz)
+      if result[:error]
+        message = @minilab_hardware.get_error_string(result[:error])
+        raise "Command [#{method}(#{argz.inspect})] caused a hardware error: #{message}"
+      end
+      result[:value]
+    end
+  end
+end

data/lib/minilab/objects.yml

@@ -0,0 +1,24 @@
+using_namespace Minilab:
+  minilab:
+    compose: minilab_wrapper, analog_io, digital_auxport_io, digital_port_io, connection_state
+
+  connection_state:
+
+  minilab_wrapper:
+    compose: minilab_hardware
+
+  minilab_hardware:
+
+  analog_io:
+    compose: minilab_wrapper
+
+  digital_auxport_io:
+    compose: minilab_wrapper
+
+  digital_port_io:
+    compose: minilab_wrapper, digital_configuration, library_translator
+
+  library_translator:
+
+  digital_configuration:
+    compose: minilab_wrapper

data/lib/minilab/version.rb

@@ -0,0 +1,3 @@
+module Minilab
+  VERSION = "2.0.0"
+end

data/lib/minilab.rb

@@ -0,0 +1,14 @@
+require "constructor"
+
+require_relative "minilab/minilab_constants"
+require_relative "minilab/minilab_context"
+
+require_relative "minilab/analog_io"
+require_relative "minilab/connection_state"
+require_relative "minilab/digital_auxport_io"
+require_relative "minilab/digital_configuration"
+require_relative "minilab/digital_port_io"
+require_relative "minilab/library_translator"
+require_relative "minilab/minilab"
+require_relative "minilab/minilab_hardware"
+require_relative "minilab/minilab_wrapper"

data/minilab.gemspec

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "minilab/version"
+
+Gem::Specification.new do |s|
+  s.name        = "minilab"
+  s.version     = Minilab::VERSION
+  s.platform    = Gem::Platform::CURRENT
+  s.authors     = ["Matt Fletcher"]
+  s.email       = ["fletcher@atomicobject.com"]
+  s.homepage    = "http://atomicobject.github.com/minilab"
+  s.summary     = %q{Ruby interface to Measurement Computing's miniLAB 1008}
+  s.description = "#{s.summary} "
+
+  s.add_dependency "constructor", "~>2.0"
+  s.add_dependency "diy", "~>1.1"
+  s.add_dependency "ffi", "~>1.0"
+
+  s.add_development_dependency "steak", "~>1.0"
+  s.add_development_dependency "rr", "~>1.0"
+
+  s.rubyforge_project = "minilab"
+
+  s.has_rdoc         = true
+  s.extra_rdoc_files = %w[ README.rdoc CHANGES LICENSE ]
+  s.rdoc_options     = %w[ --main README.rdoc --title minilab ]
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/spec/acceptance/analog_spec.rb

@@ -0,0 +1,35 @@
+require_relative "../spec_helper"
+
+feature "Analog" do
+  scenario "inputs" do
+    analog_input_4_should_be_about 5.0
+
+    analog_input_1_should_be_about 0.0
+  end
+
+  scenario "outputs" do
+    write_analog_1 5.0
+    analog_input_0_should_be_about 5.0
+
+    write_analog_1 0.0
+    analog_input_0_should_be_about 0.0
+
+    write_analog_1 2.77
+    analog_input_0_should_be_about 2.77
+
+    write_analog_1 3.19
+    analog_input_0_should_be_about 3.19
+
+    write_analog_0 5.0
+    analog_input_6_should_be_about 5.0
+
+    write_analog_0 0.0
+    analog_input_6_should_be_about 0.0
+
+    write_analog_0 3.75
+    analog_input_6_should_be_about 3.75
+
+    write_analog_0 1.88
+    analog_input_6_should_be_about 1.88
+  end
+end

data/spec/acceptance/digital_port_spec.rb

@@ -0,0 +1,81 @@
+require_relative "../spec_helper"
+
+feature "Digital ports" do
+  scenario "reading bits" do
+    configure_portb_for_input
+    digital_pin_10_should_be 1
+
+    configure_porta_for_input
+    digital_pin_30_should_be 0
+  end
+
+  scenario "writing bits" do
+    # Port A --> Port B
+    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
+    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
+    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
+    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
+  end
+
+  scenario "reading bytes" do
+    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
+  end
+end

data/spec/acceptance/digital_screw_terminal_spec.rb

@@ -0,0 +1,22 @@
+require_relative "../spec_helper"
+
+feature "Digital screw terminals" do
+  scenario "input" do
+    dio1_should_be 1
+    dio2_should_be 0
+  end
+
+  scenario "output" do
+    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
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,102 @@
+require_relative "../lib/minilab"
+require "steak"
+
+module MinilabUnitSpecHelpers
+  def create_mocks(*mox)
+    mox.inject({}) do |bag, name|
+      the_mock = Object.new
+      self.instance_variable_set("@#{name}", mock(the_mock))
+      bag[name] = the_mock
+      bag
+    end
+  end
+end
+
+module MinilabAcceptanceSpecHelpers
+  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
+
+  # Analog input methods
+  0.upto(7) do |channel|
+    define_method("analog_input_#{channel}_should_be_about") do |value|
+      input = @minilab.read_analog(channel)
+      assert_in_delta(value, input, GOOD_DELTA, "Input voltage was not ~#{value} volts")
+    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)
+      sleep 0.1
+    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
+
+  # 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
+  
+  # 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
+end
+
+RSpec.configure do |config|
+  # Using both to minimize the amount of porting work.
+  # most assertions are still test:unit based, but some
+  # (like exceptions) us rspec
+  config.expect_with :stdlib, :rspec
+  config.mock_framework = :rr
+
+  config.include Minilab::MinilabConstants
+
+  config.include MinilabUnitSpecHelpers
+  config.include MinilabAcceptanceSpecHelpers, :type => :acceptance
+  config.before(:all, :type => :acceptance) do
+    @minilab = Minilab.build
+    @minilab.connect
+  end
+end

data/spec/unit/analog_io_spec.rb

@@ -0,0 +1,55 @@
+require_relative "../spec_helper"
+
+describe Minilab::AnalogIo do
+  before { @mox = create_mocks(:minilab_wrapper) }
+  subject { described_class.new(@mox) }
+
+  it "read analog data" do
+    @minilab_wrapper.read_analog(2).returns 5.7
+    assert_equal 5.7, subject.read_analog(2)
+  end
+
+  it "raise an exception when analog input channel is out of range" do
+    # The minilab device has 8 analog inputs (when used in straight
+    # input mode, not differential). We expect that exceptions
+    # it be thrown for channels that are out of bounds.
+    -> { subject.read_analog(-1) }.should raise_error
+    0.upto(7) do |channel|
+      @minilab_wrapper.read_analog(channel).returns(1.0)
+      -> { subject.read_analog(channel) }.should_not raise_error
+    end
+    -> { subject.read_analog(8) }.should raise_error
+  end
+
+  it "write analog data" do
+    @minilab_wrapper.write_analog(1, 4.5)
+    subject.write_analog(1, 4.5)
+  end
+
+  it "raise an error when analog output voltage is out of range" do
+    -> { subject.write_analog(0, -0.1) }.should raise_error
+
+    @minilab_wrapper.write_analog(0, 0.0)
+    -> { subject.write_analog(0, 0.0) }.should_not raise_error
+
+    @minilab_wrapper.write_analog(0, 2.1)
+    -> { subject.write_analog(0, 2.1) }.should_not raise_error
+
+    @minilab_wrapper.write_analog(0, 5.0)
+    -> { subject.write_analog(0, 5.0) }.should_not raise_error
+
+    -> { subject.write_analog(0, 5.1) }.should raise_error
+  end
+  
+  it "raise an error when analog output channel is out of range" do
+    -> { subject.write_analog(-1, 0.0) }.should raise_error
+
+    @minilab_wrapper.write_analog(0, 0.0)
+    -> { subject.write_analog(0, 0.0) }.should_not raise_error
+
+    @minilab_wrapper.write_analog(1, 0.0)
+    -> { subject.write_analog(1, 0.0) }.should_not raise_error
+
+    -> { subject.write_analog(2, 0.0) }.should raise_error
+  end
+end

data/spec/unit/connection_state_spec.rb

@@ -0,0 +1,14 @@
+require_relative "../spec_helper.rb"
+
+describe Minilab::ConnectionState do
+  it "default to an unconnected state" do
+    assert_equal false, subject.connected?
+  end
+
+  it "allow the connection state to be changed" do
+    subject.connected = true
+    assert_equal true, subject.connected?
+    subject.connected = false
+    assert_equal false, subject.connected?
+  end
+end

data/spec/unit/digital_auxport_io_spec.rb

@@ -0,0 +1,98 @@
+require_relative "../spec_helper"
+
+describe Minilab::DigitalAuxportIo do
+  before { @mox = create_mocks(:minilab_wrapper) }
+  subject { described_class.new(@mox) }
+
+  it "read digital data from the screw terminals" do
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.read_auxport(get_pin_number("DIO1")).returns 1
+
+    assert_equal 1, subject.read_digital('DIO1')
+  end
+
+  it "raise an error when digital input pin is not valid" do
+    make_sure_bad_pins_blow_up
+
+    good_pins.each do |pin|
+      expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number(pin) }
+      @minilab_wrapper.configure_auxport(expected_configuration)
+      @minilab_wrapper.read_auxport(get_pin_number(pin)).returns 0
+      -> { subject.read_digital(pin) }.should_not raise_error
+    end
+  end
+
+  # Output tests
+  it "write digital data to the screw terminals" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.write_auxport(get_pin_number("DIO1"), 1)
+
+    subject.write_digital("DIO1", 1)
+  end
+
+  it "write 1 to a digital output when the commanded value is anything not 0" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.write_auxport(get_pin_number("DIO1"), 1)
+    subject.write_digital("DIO1", 173)
+
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.write_auxport(get_pin_number("DIO1"), 1)
+    subject.write_digital("DIO1", 872)
+  end
+
+  it "raise an exception if someone tries to command a negative value" do
+    -> { subject.write_digital("DIO2", -1) }.should raise_error
+    -> { subject.write_digital("DIO2", -80) }.should raise_error
+  end
+  
+  it "raise an exception when digital output pin is out of range" do
+    make_sure_bad_pins_blow_up
+
+    good_pins.each do |pin|
+      expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number(pin) }
+      @minilab_wrapper.configure_auxport(expected_configuration)
+      @minilab_wrapper.write_auxport(get_pin_number(pin), 1)
+      -> { subject.write_digital(pin, 1) }.should_not raise_error
+    end
+  end
+
+  it "accept case-insensitive DIO strings as pins" do
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO1") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.write_auxport(get_pin_number("DIO1"), 1)
+    subject.write_digital('dio1', 1)
+
+    expected_configuration = { :direction => DIGITALOUT, :pin => get_pin_number("DIO2") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.write_auxport(get_pin_number("DIO2"), 1)
+    subject.write_digital('dIo2', 1)
+
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO0") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.read_auxport(get_pin_number("DIO0")).returns 1
+    subject.read_digital('DiO0')
+
+    expected_configuration = { :direction => DIGITALIN, :pin => get_pin_number("DIO3") }
+    @minilab_wrapper.configure_auxport(expected_configuration)
+    @minilab_wrapper.read_auxport(get_pin_number("DIO3")).returns 1
+    subject.read_digital('diO3')
+  end
+
+  private
+  def get_pin_number(pin)
+    pin.match(/(\d)$/)[0].to_i
+  end
+
+  def good_pins
+    %w[ DIO0 DIO1 DIO2 DIO3 ]
+  end
+
+  def make_sure_bad_pins_blow_up
+    [ 'yourmom', 'bill', nil, false, 55, 'DIO4', -1, 38 ].each do |pin|
+      -> { subject.read_digital(pin) }.should raise_error
+    end
+  end
+end