minilab 1.1.0-x86-mswin32-60

data/lib/minilab.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../config/environment.rb"
+
+# The main interface to the minilab library. Create one of these objects
+# using the +build+ class method. After you've created a minilab object,
+# use the +connect+ method to establish the connection to the device.
+# Minilab objects are not usable until they've been connected.
+class Minilab
+  include MinilabConstants
+  constructor :minilab_wrapper, :analog_io, :digital_auxport_io, :digital_port_io, :connection_state
+
+  # Use this method to construct Minilab objects. The object will not yet
+  # be connected to the device.
+  def self.build
+    MinilabContext.new.build[:minilab]
+  end
+
+  # Connect to the device. There are two side effects of connecting.
+  # * Error reporting from MCC's universal library is set to print
+  #   errors to standard out instead of popping up a Windows dialog.
+  # * Each of the DB37 digital ports is setup for input.
+  def connect
+    @minilab_wrapper.setup_error_handling(DONTPRINT, STOPALL)
+    @minilab_wrapper.declare_revision(CURRENTREVNUM)
+    @connection_state.connected = true
+    DigitalConfiguration::PORTS.each { |port| configure_input_port(port) }
+  end
+
+  # Read from one of the eight analog channels (0 - 7) on top of the device.
+  #
+  # Single-ended mode is the only analog mode supported.
+  #
+  # An error is raised if an invalid channel number is given.
+  def read_analog(channel)
+    ensure_connected_to_device
+    @analog_io.read_analog(channel)
+  end
+
+  # Output a voltage on one of the eight analog channels. The output voltage
+  # must be in the range of 0.0 - 5.0 volts.
+  #
+  # Single-ended mode is the only analog mode supported.
+  #
+  # An error is raised if an invalid channel number or an out-of-range
+  # voltage is given.
+  def write_analog(channel, volts)
+    ensure_connected_to_device
+    @analog_io.write_analog(channel, volts)
+  end
+
+  # Configure one of the DB37 ports for input.
+  #
+  # Specify _port_ as a symbol. The available ports are <tt>:porta</tt>,
+  # <tt>:portb</tt>, <tt>:portcl</tt>, and <tt>:portch</tt>. An error is 
+  # raised if an invalid port is given.
+  def configure_input_port(port)
+    ensure_connected_to_device
+    @digital_port_io.configure_input_port(port)
+  end
+
+  # Configure one of the DB37 ports for output.
+  #
+  # Specify _port_ as a symbol. The available ports are <tt>:porta</tt>,
+  # <tt>:portb</tt>, <tt>:portcl</tt>, and <tt>:portch</tt>. An error is
+  # raised if an invalid port is given.
+  def configure_output_port(port)
+    ensure_connected_to_device
+    @digital_port_io.configure_output_port(port)
+  end
+
+  # Read a single bit from one of the digital pins.
+  #
+  # If you'd like to read from one of the pins on the top of the device (the
+  # auxport pins), then specify the pin as a string with its label (e.g. 
+  # read_digital("DIO1")). Alternatively, if you'd like to read from one of
+  # the DB37 pins, specify the pin as the number it's labeled with (e.g.
+  # read_digital(13)).
+  #
+  # An error is raised if you specify a pin that doesn't exist or if you
+  # try to read from a DB37 pin on a port that is not configured for input.
+  # The digital pins on the top of the device do not need to be configured.
+  def read_digital(pin)
+    ensure_connected_to_device
+    perform_digital_op(pin, :read, pin)
+  end
+  
+  # Write a single bit to one of the digital pins. _value_ must be an integer
+  # 1 or 0.
+  #
+  # If you'd like to write to one of the pins on the top of the device (the
+  # auxport pins), then specify the pin as a string with its label (e.g. 
+  # write_digital("DIO2", 0)). Alternatively, if you'd like to write to one
+  # of the DB37 pins, specify the pin as the number it's labeled with (e.g. 
+  # write_digital(17, 1)).
+  #
+  # An error is raised if you specify a pin that doesn't exist or if you
+  # try to write to a DB37 pin on a port that is not configured for output.
+  # The digital pins on the top of the device do not need to be configured.
+  #
+  # Values above 1 are interpreted as 1; negative values raise an error.
+  def write_digital(pin, value)
+    ensure_connected_to_device
+    perform_digital_op(pin, :write, pin, value)
+  end
+
+  # Read a byte from one of the DB37 ports.
+  #
+  # Specify _port_ as a symbol. The available ports are <tt>:porta</tt>,
+  # <tt>:portb</tt>, <tt>:portcl</tt>, and <tt>:portch</tt>.
+  #
+  # An error is raised if an invalid port is given.
+  def read_digital_byte(port)
+    ensure_connected_to_device
+    @digital_port_io.read_port(port)
+  end
+
+  private
+  def perform_digital_op(pin, op, *args)
+    method = "#{op.to_s}_digital"
+    case pin
+    when String
+      @digital_auxport_io.send(method,*args)
+    when Fixnum
+      @digital_port_io.send(method,*args)
+    end
+  end
+
+  def ensure_connected_to_device
+    raise "Cannot use any minilab methods without calling 'connect' first." unless @connection_state.connected?
+  end
+end

data/lib/minilab_constants.rb

@@ -0,0 +1,20 @@
+# Lifted from cbw.h. Let's hope these don't change often.
+# Using revision number 5.90.
+module MinilabConstants
+  CURRENTREVNUM = 5.90
+
+  BOARDNUM = 0
+  DONTPRINT = 0
+  STOPALL = 2
+  ERRSTRLEN = 256
+  BIP10VOLTS = 1
+  UNI5VOLTS = 101
+
+  AUXPORT = 1
+  DIGITALOUT = 1
+  DIGITALIN = 2
+  FIRSTPORTA = 10
+  FIRSTPORTB = 11
+  FIRSTPORTCL = 12
+  FIRSTPORTCH = 13
+end

data/lib/minilab_context.rb

@@ -0,0 +1,14 @@
+require 'yaml'
+
+class MinilabContext #:nodoc:
+  OBJECT_DEFINITION = APP_ROOT + "/config/objects.yml"
+
+  def build
+    if not @context
+      DIY::Context.auto_require = false
+      @context = DIY::Context.new(YAML.load_file(OBJECT_DEFINITION))
+      @context.build_everything
+    end
+    @context
+  end
+end

data/lib/minilab_hardware.rb

@@ -0,0 +1,112 @@
+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
+
+  extend FFI::Library
+  ffi_lib "cbw32.dll"
+
+  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

data/lib/minilab_wrapper.rb

@@ -0,0 +1,12 @@
+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

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,83 @@
+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