minilab 1.0.0-mswin32

data/lib/digital_port_io.rb

@@ -0,0 +1,68 @@
+require 'constructor'
+
+class DigitalPortIo #:nodoc:
+  constructor :minilab_hardware, :result_verifier, :digital_configuration, :library_translator
+
+  def get_valid_ports
+    @digital_configuration.get_valid_ports
+  end
+
+  def configure_input_port(port)
+    @digital_configuration.configure_port_for_input(port)
+  end
+  
+  def configure_output_port(port)
+    @digital_configuration.configure_port_for_output(port)
+  end
+
+  def read_digital(pin)
+    check_pin_configuration(pin, :input)
+    pin = get_library_pin_number(pin)
+
+    access_hardware(:read_digital_pin, pin)
+  end
+
+  def write_digital(pin, value)
+    check_pin_configuration(pin, :output)
+    pin = get_library_pin_number(pin)
+
+    access_hardware(:write_digital_pin, pin, value)
+    true
+  end
+
+  def read_port(port)
+    raise "#{port} is an invalid port." unless get_valid_ports.include?(port)
+
+    if !@digital_configuration.is_port_configured_for_input?(port)
+      raise "Digital port #{port} is not configured for input."
+    end
+
+    access_hardware("read_port", get_library_port(port))
+  end
+
+  private
+  def get_port(pin)
+    @library_translator.get_port_for_pin(pin)
+  end
+
+  def get_library_pin_number(pin)
+    @library_translator.get_library_pin_number(pin)
+  end
+
+  def get_library_port(port)
+    @library_translator.get_library_port(port)
+  end
+
+  def check_pin_configuration(pin, type)
+    port = get_port(pin)
+    if !@digital_configuration.send("is_port_configured_for_#{type}?", port)
+      raise "Digital port #{port} for pin #{pin} is not configured for #{type}."
+    end
+  end
+
+  def access_hardware(method, *args)
+    result = @minilab_hardware.send(method, *args)
+    @result_verifier.verify(result)
+    result[:value]
+  end
+end

data/lib/extension/extconf.rb

@@ -0,0 +1,4 @@
+require 'mkmf'
+
+have_library('cbw32')
+create_makefile('minilab_hardware')

data/lib/extension/minilab_hardware.c

@@ -0,0 +1,235 @@
+#include "ruby.h"
+#include "stdio.h"
+#include "cbw.h"
+
+#define BOARD_NUM 0
+
+static void define_constants();
+static VALUE create_error_and_value_hash(int error, VALUE the_value);
+static VALUE create_error_hash(int error);
+static VALUE setup_error_handling(VALUE self, VALUE error_reporting, VALUE error_handling);
+static VALUE declare_revision(VALUE self, VALUE revision);
+static VALUE get_revision(VALUE self);
+static VALUE get_error_string(VALUE self, VALUE error);
+static VALUE configure_auxport(VALUE self, VALUE optz);
+static VALUE configure_port(VALUE self, VALUE optz);
+static VALUE read_analog(VALUE self, VALUE channel);
+static VALUE read_digital_pin(VALUE self, VALUE pin);
+static VALUE read_auxport(VALUE self, VALUE pin);
+static VALUE read_port(VALUE self, VALUE port);
+static VALUE write_analog(VALUE self, VALUE channel, VALUE volts);
+static VALUE write_digital_pin(VALUE self, VALUE pin, VALUE data);
+static VALUE write_auxport(VALUE self, VALUE pin, VALUE data);
+
+VALUE MinilabHardware;
+
+/* :nodoc: */
+void Init_minilab_hardware()
+{
+  define_constants();
+
+	MinilabHardware = rb_define_class("MinilabHardware", rb_cObject);
+  rb_define_method(MinilabHardware, "setup_error_handling", setup_error_handling, 2);
+  rb_define_method(MinilabHardware, "declare_revision", declare_revision, 1);
+  rb_define_method(MinilabHardware, "get_revision", get_revision, 0);
+  rb_define_method(MinilabHardware, "get_error_string", get_error_string, 1);
+  rb_define_method(MinilabHardware, "configure_auxport", configure_auxport, 1);
+  rb_define_method(MinilabHardware, "configure_port", configure_port, 1);
+  rb_define_method(MinilabHardware, "read_analog", read_analog, 1);
+  rb_define_method(MinilabHardware, "read_digital_pin", read_digital_pin, 1);
+  rb_define_method(MinilabHardware, "read_auxport", read_auxport, 1);
+  rb_define_method(MinilabHardware, "read_port", read_port, 1);
+  rb_define_method(MinilabHardware, "write_analog", write_analog, 2);
+  rb_define_method(MinilabHardware, "write_digital_pin", write_digital_pin, 2);
+  rb_define_method(MinilabHardware, "write_auxport", write_auxport, 2);
+}
+
+/* :nodoc: */
+static void define_constants()
+{
+  VALUE minilab_constants = rb_define_module("MinilabConstants");
+  rb_define_const(minilab_constants, "DONTPRINT", INT2NUM(DONTPRINT));
+  rb_define_const(minilab_constants, "STOPALL", INT2NUM(STOPALL));
+  rb_define_const(minilab_constants, "CURRENTREVNUM", INT2NUM(CURRENTREVNUM));
+  rb_define_const(minilab_constants, "DIGITALIN", INT2NUM(DIGITALIN));
+  rb_define_const(minilab_constants, "DIGITALOUT", INT2NUM(DIGITALOUT));
+  rb_define_const(minilab_constants, "FIRSTPORTA", INT2NUM(FIRSTPORTA));
+  rb_define_const(minilab_constants, "FIRSTPORTB", INT2NUM(FIRSTPORTB));
+  rb_define_const(minilab_constants, "FIRSTPORTCL", INT2NUM(FIRSTPORTCL));
+  rb_define_const(minilab_constants, "FIRSTPORTCH", INT2NUM(FIRSTPORTCH));
+}
+
+// Public functions.
+// Setup stuff
+static VALUE setup_error_handling(VALUE self, VALUE error_reporting, VALUE error_handling)
+{
+  int error = cbErrHandling(error_reporting, error_handling);
+  return create_error_hash(error);
+}
+
+static VALUE declare_revision(VALUE self, VALUE revision)
+{
+  float the_revision = NUM2DBL(revision);
+  int error = cbDeclareRevision(&the_revision);
+  return create_error_hash(error);
+}
+
+static VALUE get_revision(VALUE self)
+{
+  float dll_revision_number;
+  float vxd_revision_number;
+  int error;
+
+  error = cbGetRevision(&dll_revision_number, &vxd_revision_number);
+
+  return create_error_and_value_hash(error, rb_float_new(dll_revision_number));
+}
+
+static VALUE get_error_string(VALUE self, VALUE error)
+{
+  int new_error;
+  char message[ERRSTRLEN];
+
+  new_error = cbGetErrMsg(error, message);
+  if (new_error)
+    return create_error_hash(error);
+
+  return rb_str_new2(message);
+}
+
+static VALUE configure_auxport(VALUE self, VALUE optz)
+{
+  int error;
+  VALUE pin;
+  VALUE direction;
+
+  pin = rb_hash_aref(optz, ID2SYM(rb_intern("pin")));
+  if (NIL_P(pin) != 0) {
+    rb_raise(rb_eRuntimeError, ":pin is a required parameter");
+  }
+
+  direction = rb_hash_aref(optz, ID2SYM(rb_intern("direction")));
+  if (NIL_P(direction) != 0) {
+    rb_raise(rb_eRuntimeError, ":direction is a required parameter");
+  }
+
+  error = cbDConfigBit(BOARD_NUM, AUXPORT, NUM2UINT(pin), NUM2UINT(direction));
+
+  return create_error_hash(error);
+}
+
+static VALUE configure_port(VALUE self, VALUE optz)
+{
+  int error;
+  VALUE port;
+  VALUE direction;
+
+  port = rb_hash_aref(optz, ID2SYM(rb_intern("port")));
+  if (NIL_P(port) != 0) {
+    rb_raise(rb_eRuntimeError, ":port is a required parameter");
+  }
+
+  direction = rb_hash_aref(optz, ID2SYM(rb_intern("direction")));
+  if (NIL_P(direction) != 0) {
+    rb_raise(rb_eRuntimeError, ":direction is a required parameter");
+  }
+
+  error = cbDConfigPort(BOARD_NUM, NUM2UINT(port), NUM2UINT(direction));
+
+  return create_error_hash(error);
+}
+
+// IO functions
+static VALUE read_analog(VALUE self, VALUE channel)
+{
+  unsigned short raw_data;
+  float voltage;
+  int error;
+
+  error = cbAIn(BOARD_NUM, NUM2UINT(channel), BIP10VOLTS, &raw_data);
+  if (error)
+    return create_error_hash(error);
+  
+  error = cbToEngUnits(BOARD_NUM, BIP10VOLTS, raw_data, &voltage);
+
+  return create_error_and_value_hash(error, rb_float_new(voltage));
+}
+
+static VALUE read_digital_pin(VALUE self, VALUE pin)
+{
+  unsigned short data;
+  int error;
+
+  error = cbDBitIn(BOARD_NUM, FIRSTPORTA, NUM2UINT(pin), &data);
+  
+  return create_error_and_value_hash(error, UINT2NUM(data));
+}
+
+static VALUE read_auxport(VALUE self, VALUE pin)
+{
+  unsigned short data;
+  int error;
+
+  error = cbDBitIn(BOARD_NUM, AUXPORT, NUM2UINT(pin), &data);
+  
+  return create_error_and_value_hash(error, UINT2NUM(data));
+}
+
+static VALUE read_port(VALUE self, VALUE port)
+{
+  unsigned short data;
+  int error;
+
+  error = cbDIn(BOARD_NUM, NUM2UINT(port), &data);
+  return create_error_and_value_hash(error, UINT2NUM(data));
+}
+
+static VALUE write_analog(VALUE self, VALUE channel, VALUE volts)
+{
+  unsigned short raw_data;
+  int error;
+
+  error = cbFromEngUnits(BOARD_NUM, UNI5VOLTS, NUM2DBL(volts), &raw_data);
+  if (error)
+    return create_error_hash(error);
+
+  error = cbAOut(BOARD_NUM, NUM2UINT(channel), UNI5VOLTS, raw_data);
+
+  return create_error_hash(error);
+}
+
+static VALUE write_digital_pin(VALUE self, VALUE pin, VALUE data)
+{
+  int error;
+  
+  error = cbDBitOut(BOARD_NUM, FIRSTPORTA, NUM2UINT(pin), NUM2UINT(data));
+
+  return create_error_hash(error);
+}
+
+static VALUE write_auxport(VALUE self, VALUE pin, VALUE data)
+{
+  int error;
+  
+  error = cbDBitOut(BOARD_NUM, AUXPORT, NUM2UINT(pin), NUM2UINT(data));
+
+  return create_error_hash(error);
+}
+
+// Helpers
+static VALUE create_error_and_value_hash(int error, VALUE the_value)
+{
+  VALUE result = rb_hash_new();
+
+  if (error)
+    rb_hash_aset(result, ID2SYM(rb_intern("error")), INT2NUM(error));
+  else
+    rb_hash_aset(result, ID2SYM(rb_intern("value")), the_value);
+  
+  return result;
+}
+
+static VALUE create_error_hash(int error)
+{
+  return create_error_and_value_hash(error, Qtrue);
+}

data/lib/library_translator.rb

@@ -0,0 +1,48 @@
+require 'extension/minilab_hardware'
+
+class LibraryTranslator #:nodoc:
+  include MinilabConstants
+
+  def get_port_for_pin(pin)
+    case pin
+    when 30..37
+      :porta
+    when 3..10
+      :portb
+    when 26..29
+      :portcl
+    when 22..25
+      :portch
+    else
+      raise "Pin #{pin} does not map to a known minilab DB37 port."
+    end
+  end
+
+  def get_library_pin_number(pin)
+    case pin
+    when 30..37  # port a pins
+      7 - (pin - 30)
+    when 3..10   # port b pins
+      15 - (pin - 3)
+    when 26..29  # port cl pins
+      19 - (pin - 26)
+    when 22..25  # port ch pins
+      23 - (pin - 22)
+    else
+      raise "Pin #{pin} does not map to a minilab library pin number."
+    end
+  end
+  
+  def get_library_port(port)
+    port_to_library_port_mapping = {
+      :porta => FIRSTPORTA,
+      :portb => FIRSTPORTB,
+      :portcl => FIRSTPORTCL,
+      :portch => FIRSTPORTCH
+    }
+
+    library_port = port_to_library_port_mapping[port]
+    return library_port unless library_port.nil?
+    raise "Port #{port} is not a valid port."
+  end
+end

data/lib/minilab.rb

@@ -0,0 +1,149 @@
+require File.expand_path(File.dirname(__FILE__)) + "/../config/environment.rb"
+require 'extension/minilab_hardware'
+require 'minilab_context'
+require 'analog_io'
+require 'digital_auxport_io'
+require 'digital_port_io'
+require 'result_verifier'
+require 'constructor'
+
+# 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_hardware, :result_verifier, :analog_io,
+              :digital_auxport_io, :digital_port_io 
+
+  # 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
+    result = @minilab_hardware.setup_error_handling(DONTPRINT, STOPALL)
+    @result_verifier.verify(result, "setup_error_handling")
+
+    result = @minilab_hardware.declare_revision(CURRENTREVNUM)
+    @result_verifier.verify(result, "declare_revision")
+
+    @connected = true
+
+    @digital_port_io.get_valid_ports.each do |port|
+      configure_input_port(port)
+    end
+  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 setup
+    @connected = false
+  end
+
+  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 @connected
+  end
+end