phidgets_native 0.1.0

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gem 'rake-compiler'

data/Gemfile.lock

@@ -0,0 +1,12 @@
+GEM
+  remote: https://rubygems.org/
+  specs:
+    rake (10.1.0)
+    rake-compiler (0.8.3)
+      rake
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rake-compiler

data/README.rdoc

@@ -0,0 +1,176 @@
+=What is PhidgetsNative
+This library is a set of classes for use with the excellent USB sensing and 
+controller devices available for sale on phidgets.com. If you're a ruby programmer
+and need to interface your code with meat-space concerns, these devices (and this
+library) are what you need. 
+
+==What's a Phidget?
+Phidgets are well supported on almost any operating system, and require practically
+no knowledge of electrical engineering or digital circuitry. Each device is a stand-
+alone "plug and play" building block that works on it's own , or in conjunction
+with other phidgets.
+
+You can browse the phidget product catalog on {www.phidgets.com}[http://www.phidgets.com].
+
+==Tested Environments
+As of this writing, this gem is stable, and actively tested on:
+* x86_64 on OS X
+* x86_64 on Linux
+* armv6l on Linux
+
+Presumably most other UNIX variants will work just fine. Probably win32/win64 
+will not.
+
+==Supported Devices
+As of this version, we currently only support the following phidgets:
+* Phidget Spatial
+* Phidget GPS
+* Phidget Interface Kit
+There will soon be support for the "Phidget Servo" phidget. If you have a phidget 
+that's not on our current compatibility list, either get me a copy of the phidget 
+to work with at my desk, or check out the existing modules for a reference in 
+setting up your own class, and push your changes to my repo. Most of the difficult 
+work is done, and you'll find plenty of stubs to work with for nearly all the 
+available phidgets.
+
+=Why not Phidgets-FFI?
+Though encompassing, Phidgets-FFI is seemingly quite buggy, and a bit slow. Particularly
+with Garbage collection turned on. I think that the threading model of the Phidgets
+C API is simply incompatible with the design of the ruby-ffi library. Additionally,
+running the ffi gem on arm environments is outright unusable.
+
+Caveats aside, the Phidgets-FFI library interfaces are elegant and well thought-out, 
+and this library's interfaces (and even this README) are heavily influenced by 
+them. Converting your existing code base to use this library shouldn't be too 
+difficult.
+
+==Differences with Phidgets-FFI
+The Phidgets-FFI library has a number of methods which accept blocks. This library
+has none. Maybe that will change in the future.
+
+There are currently no plans to support event-driven interfaces. Though this was
+an excellent feature of the ffi library, it adds a significant degree of complexity
+to a stable implementation of this library. Indeed, most of the stability issues
+arise when attempting to use these features in the ffi implementation.
+
+Additionally, the phidgets-ffi implementation is a little strange with it's support
+of device disconnects and reconnects. Here in the 'native' implementation, once
+a device object is created, it stays 'active' regardless of whether the device
+is attached. If the device is disconnected and reconnected, your phidget object
+will automatically re-register its handlers with the device, and continue to 
+function as if the device were never disconnected to begin with. Keep in mind that
+any attributes relating to the device's capabilities (mostly those in the 
+Phidget::Device class, though there are things like the axial extents in the 
+spatial object) will be 'cached' from the previous connection. "State" attributes
+(such as the spatial's accelerometer output) will return nil or 0.
+
+In practice, if you need an event-driven model for your code, you can almost certainly
+get by using a ruby thread with a polling loop, like so:
+
+  is_fixed_last = false 
+  @poller = Thread.new(Phidget::GPS(12345)) do |gps| 
+    gps.wait_for_attachment(10000)
+
+    begin
+      on_fixed_change(gps.is_fixed) if is_fixed_last != gps.is_fixed
+      is_fixed_last = gps.is_fixed?
+    end while sleep(0.1) 
+  end
+
+  # Carry on with the rest of your code here
+
+I'm fairly certain that until ruby supports actual kernel-based threads, this is 
+the best you can reasonably do. Maybe we'll emulate the ffi library in this capacity
+at some point in the future, if there's a demand to do so.
+
+=Getting Started
+First, we need to set up the proper environment and get the necessary files off 
+the Phidgets website. Visit the drivers section at www.phidgets.com and get the 
+latest Phidget driver for your system. 
+
+We also recommend that you read the following reference materials:
+* {General Phidget Programming}[http://www.phidgets.com/docs/General_Phidget_Programming]
+* The {User Guide}[http://www.phidgets.com/docs/Category:UserGuide] for your device
+* {RubyDoc API Documentation}[http://rubydoc.info/gems/phidgets_native/frames]
+* {Ruby code samples}[https://github.com/kreynolds/phidgets_native/tree/master/examples]
+
+The RubyDoc API manual contains calls and events for every type of Phidget and 
+can be used as a reference. You can find a high level discussion about programming 
+with Phidgets in general on the General Phidget Programming page. 
+The user guide for your device also contains an API section that describes 
+limitations, defaults, and implementation details specific to your Phidget. 
+
+==Installing the phidgets_native gem
+To install:
+  gem install phidgets_native
+
+phidgets_native is very self contained. There's no dependencies on other ruby 
+gems or non-standard libraries. However, in order to compile this gem, you'll
+need a suitable build environment for your system (clang on OSX or gcc on Linux),
+and the aforementioned phidgets driver.
+
+==Coding for your Phidget
+Before you can use the Phidget, you must include a reference to the phidgets_native 
+gem:
+  require "rubygems"
+  require "phidgets_native"
+
+Afterwards, Phidgets can be instantiated by creating the appropriate device class 
+object, with the device serial number passed to its constructor. At the moment, 
+only the 'local' devices are supported. If there's enough interest (or contributors)
+I may add support for the 'remote' protocols which allow you to open a device
+via its computer's IP address.
+
+  spatial = PhidgetsNative::Spatial.new 54321
+
+The object name for any type of Phidget is listed in the API manual. Every type 
+of Phidget also inherits functionality from the Phidget base class (Which cannot
+be instantiated by itself directly). 
+
+If you don't know the serial number of the device you're looking for, you can 
+use the Phidget.all method to return an array of the currently connected Phidgets
+and/or you can simply run the included list_all.rb example.
+
+One important thing to remember is that when working with Phidgets, a local connection 
+will reserve the device until closed. This prevents any other instances from 
+retrieving data from the Phidget, including other programs. 
+
+==Standard accessors
+All devices support the accessors defined in the Phidget::Device class from which
+they inherit. 
+
+==A note about device availability
+Simply calling the constructor does not guarantee you can use the Phidget 
+immediately. The constructor merely sets up the Phidget handlers and event hooks,
+but does not block the interpreter while it waits for the device to register. 
+For most people, you'll want immediate access to the phidget after the class has
+been instantiated. As such, you'll need to call the wait_for_attachment method
+on your new instance in order to start accessing the device properties.
+
+The wait_for_attachment method will block until a connection is made to the 
+Phidget or until the provided timeout is exceeded.
+
+  ifkit = PhidgetsNative::InterfaceKit.new 24680
+  # halt the program for up 20000 microseconds or until the Phidget is connected:
+  ifkit.wait_for_attachment 20000 
+
+Though optional, it's recommended that you call close when you're done using your
+phidget or when quitting your program.
+
+  ifkit.close
+
+==Working with Multiple Phidgets
+Multiple Phidgets of the same or different types can easily be run inside the 
+same program. However, there is seemingly a six-device limit, which is imposed 
+by the Phidget API and/or hardware.
+
+==Logging
+The phidget api has built in debug logging which can be enabled on a global basis
+for all devices. By default, logs are sent to STDOUT, but you can optionally 
+pass a path to a text file where output can alternatively be redirected. You can
+also send your own messages to the logger, if you think you have something you
+need to add.
+
+  PhidgetsNative.enable_logging!(:verbose)
+  PhidgetsNative.log :info, "My favorite color is chartreuse"
+  PhidgetsNative.disable_logging!

data/Rakefile

@@ -0,0 +1,31 @@
+# File: Rakefile
+
+require 'rake/extensiontask'
+require 'rake/packagetask'
+require 'rdoc/task'
+
+spec = Gem::Specification.load('phidgets_native.gemspec')
+
+Rake::ExtensionTask.new 'phidgets_native', spec
+
+Gem::PackageTask.new(spec) do |pkg|
+  
+
+end
+
+RDOC_FILES = FileList["README.rdoc", "ext/phidgets_native/phidgets_native_ruby.c", 
+  "ext/phidgets_native/*_ruby.c"]
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/site/api"
+  rd.rdoc_files.include(RDOC_FILES)
+end
+
+Rake::RDocTask.new(:ri) do |rd|
+  rd.main = "README.rdoc"
+  rd.rdoc_dir = "doc/ri"
+  rd.options << "--ri-system"
+  rd.rdoc_files.include(RDOC_FILES)
+end
+

data/examples/gps.rb

@@ -0,0 +1,25 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require '%s/lib/common' % File.dirname(__FILE__)
+
+phidgets_example_for(PhidgetsNative::GPS) do |gps|
+  puts "\nPolled Values:"
+
+  i = 0
+  ConsoleTable.new( [
+    'Sample Rate', 
+    'Is Fixed', 
+    '%-18s' % 'Latitude', 
+    '%-18s' % 'Longitude', 
+    '%-18s' % 'Altitude', 
+    'Heading', 
+    '%-18s' % 'Velocity', 
+    '%-23s' % 'Time (UTC)'
+  ] ).output(:header => (i == 0), :separator => false) do |columns|
+    i+=1
+    [ [ '%s Hz' % gps.sample_rate ] + [gps.is_fixed?, gps.latitude, 
+      gps.longitude, gps.altitude, gps.heading, gps.velocity].collect(&:inspect)+[
+      (gps.now_at_utc) ? gps.now_at_utc.strftime("%Y-%m-%d %H:%M:%S.%3N") : nil.inspect ] ]
+  end while sleep(3)
+end

data/examples/interface_kit.rb

@@ -0,0 +1,61 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require '%s/lib/common' % File.dirname(__FILE__)
+
+#PhidgetsNative.enable_logging! :verbose
+
+additional_attribs = [
+  %w(Digital\ Inputs input_count),
+  %w(Digital\ Outputs output_count),
+  %w(Analog\ Inputs sensor_count),
+  %w(Change\ Triggers change_triggers),
+  %w(Data\ Rates data_rates),
+  %w(Data\ Rates\ Min data_rates_min),
+  %w(Data\ Rates\ Max data_rates_max)
+]
+
+phidgets_example_for(PhidgetsNative::InterfaceKit, additional_attribs) do |ifkit|
+  # Here's how you set digital outputs:
+  (0...ifkit.output_count).each{ |i| ifkit.output i, i.even? }
+
+  # Let's adjust the data rates on each input a bit:
+  (0...ifkit.sensor_count).each do |i| 
+    case (i % 4)
+      when 0
+      when 1
+        ifkit.data_rate i, ifkit.data_rates_max[i]
+      when 2
+        ifkit.change_trigger i, 1
+      when 3
+        ifkit.data_rate i, ifkit.data_rates_min[i]
+    end
+  end
+
+  # Test sensor_raw
+  puts "Raw Analog sensor values:"
+  ConsoleTable.new((0...ifkit.sensor_count).collect{|i| "Sensor #{i}"}).output do 
+    [(0...ifkit.sensor_count).collect{|i| ifkit.sensor_raw(i).inspect } ]
+  end
+
+  puts "\nPolled Values:"
+  i = 0
+  ConsoleTable.new([
+    'Input Sample Rates',
+    'Sensor Sample Rates',
+    'Ratiometric?',
+    '%-40s' % 'sensors', 
+    '%-20s' % 'inputs',
+    '%-20s' % 'outputs'
+  ]).output(:header => (i == 0), :separator => false) do |columns|
+    i+=1
+
+    #TODO Test the ratiometric set at some point
+
+    [ [ifkit.input_sample_rates, ifkit.sensor_sample_rates, ifkit.ratiometric?.inspect, 
+      ifkit.sensors.inspect]+[ifkit.inputs, ifkit.outputs].collect{ |bools|
+        (bools.kind_of? Array) ? 
+          '[%s]' % bools.collect{|b| (b) ? '1' : '0'  }.join(', ') : bools.inspect}
+    ]
+  end while sleep(3)
+end

data/examples/lib/common.rb

@@ -0,0 +1,51 @@
+# encoding: UTF-8
+
+$:.push *['%s/../../lib/', '%s'].collect{|p| p % File.dirname(__FILE__) }
+
+require 'console_table'
+require 'phidgets_native'
+
+# To keep things DRY, I went ahead and put this here:
+def phidgets_example_for(device_klass, extended_attribs = [], &block)
+
+  serial_number = $1.to_i if ARGV.length == 1 && /\A([\d]+)\Z/.match(ARGV[0])
+
+  unless serial_number
+    puts "Invalid or non-existant device serial number. This is a required parameter"
+    puts
+    puts "Usage: %s [device_serial]" % File.basename($PROGRAM_NAME)
+    exit 1
+  end
+
+  device = device_klass.new serial_number
+
+  trap("SIGINT"){ device.close; exit }
+
+  begin
+    device.wait_for_attachment 10000
+  rescue PhidgetsNative::TimeoutError
+    puts "Unable to enumerate the phidget of type %s with the serial number %d." % [
+      device.class.to_s, device.serial_number]
+    exit
+  end
+
+  puts "Using Library version: "+PhidgetsNative::LIBRARY_VERSION
+
+  puts "\nDevice Attributes:"
+
+
+  ConsoleTable.new(%w(Attribute Value)).output do
+    [ ["Type", device.type.inspect],
+      ["Name", device.name.inspect],
+      ["Label", device.label.inspect],
+      ["Serial", device.serial_number.inspect],
+      ["Version", device.version.inspect],
+      ["Device class", device.device_class.inspect],
+      ["Device id", device.device_id.inspect] ]+extended_attribs.collect{|pairs|
+        label, attr = pairs
+        [label, device.send(attr.to_sym)]
+      }
+  end
+
+  block.call(device)
+end

data/examples/lib/console_table.rb

@@ -0,0 +1,38 @@
+# encoding: UTF-8
+
+# Just a quickie hack-class I made to make the test scripts easier to understand
+# and DRY
+class ConsoleTable
+  ERR_ROW_LENGTH = "All Rows must have the same number of columns"
+
+  def initialize(column_labels)
+    @columns = column_labels
+  end
+
+  def output(options = {}, &block)
+    rows = block.call(@columns)
+    if rows.length > 0
+      raise StandardError, ERR_ROW_LENGTH if rows.any?{|r| r.length != @columns.length}
+  
+      # Find the widest cell widths:
+      widths = ([@columns]+rows).inject(Array.new(@columns.length,0)){|ret, row| 
+        (0...row.length).collect{|i| (ret[i] >= row[i].to_s.length) ? ret[i] : row[i].to_s.length }
+      }
+
+      # Construct the separator and end_cap rows:
+      end_cap, separator = %w(+%s+ |%s|).collect{|fmt| 
+        fmt % widths.collect{|width| "-" * (width+4) }.join('|') 
+      }
+
+      row_fmt = '|  %s  |' % widths.collect{|width| "%-#{width}s"}.join('  |  ')
+
+      puts [
+        (options[:header] == false) ? nil : [ end_cap, row_fmt % @columns, separator],
+        rows.to_enum(:each_with_index).collect{ |row,i | 
+          [ (options[:separator] == false || i == 0) ? nil : separator, row_fmt % row ] }, 
+        (options[:footer] == false) ? nil : end_cap
+      ].flatten.compact.join("\n")
+    end
+  end
+end
+

data/examples/list_all.rb

@@ -0,0 +1,16 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+$:.push *['%s/../lib/', '%s/lib/'].collect{|p| p % File.dirname(__FILE__) }
+require 'console_table'
+require 'phidgets_native'
+
+PhidgetsNative.enable_logging! :verbose
+
+puts "Using Library version: "+PhidgetsNative::LIBRARY_VERSION
+
+ConsoleTable.new(%w(Serial\ No. Type Class Name Version)).output do
+  PhidgetsNative.all.enum_for(:each_with_index).collect{ |p,i|
+    %w(serial_number type device_class name version).collect{|attr| p.send attr}
+  }
+end

data/examples/spatial.rb

@@ -0,0 +1,53 @@
+#!/usr/bin/env ruby
+# encoding: UTF-8
+
+require '%s/lib/common' % File.dirname(__FILE__)
+
+additional_attribs = [
+  %w(Compass\ Correction compass_correction),
+  %w(Data\ Rate data_rate),
+  %w(Data\ Rate\ Max data_rate_max),
+  %w(Data\ Rate\ Min data_rate_min),
+  %w(Accelerometer\ Axes accelerometer_axes),
+  %w(Accelerometer\ Min accelerometer_min),
+  %w(Accelerometer\ Max accelerometer_max),
+  %w(Gyroscope\ Axes gyro_axes),
+  %w(Gyroscope\ Min gyro_min),
+  %w(Gyroscope\ Max gyro_max),
+  %w(Compass\ Axes compass_axes),
+  %w(Compass\ Min compass_min),
+  %w(Compass\ Max compass_max)
+]
+
+phidgets_example_for( PhidgetsNative::Spatial, additional_attribs ) do |spatial|
+  # This is worth doing before you start to use a gyro: 
+  spatial.zero_gyro!
+ 
+  # This is worth doing as well: 
+  spatial.compass_correction = [ 0.441604, 0.045493, 0.176548, 0.002767, 1.994358, 
+    2.075937, 2.723117, -0.019360, -0.008005, -0.020036, 0.007017, -0.010891, 0.009283 ]
+
+  # This is almost never worth doing. I just put it in here for demonstration
+  # and test purposes
+  spatial.reset_compass_correction!
+
+  # Probably you'll never need to do this either:
+  spatial.data_rate = 16
+
+  puts "\nPolled Values:"
+
+  i = 0
+  ConsoleTable.new([
+    'Sample Rate', 
+    '%-40s' % 'Accelerometer', 
+    '%-40s' % 'Gyroscope',
+    '%-40s' % 'Compass'
+  ]).output(:header => (i == 0), :separator => false) do |columns|
+    i+=1
+    [ ['%d Hz' % spatial.sample_rate]+[ 
+      spatial.accelerometer, spatial.gyro, spatial.compass ].collect{ |axes|
+      (axes.kind_of? Array) ? 
+        '[%s]' % axes.collect{|a| '%0.6f' % a}.join(', ') : axes.inspect
+    } ]
+  end while sleep(3)
+end

data/ext/phidgets_native/accelerometer_ruby.c

@@ -0,0 +1,36 @@
+#include "phidgets_native.h"
+
+/* 
+ * Document-class: PhidgetsNative::Accelerometer < PhidgetsNative::Device
+ *
+ * This class is a stub, and is currently in need of an actual implementation.
+ * Nonetheless, all of the methods from its parent class PhidgetsNative::Device are 
+ * available.
+ */
+
+void Init_phidgets_native_accelerometer(VALUE m_Phidget) {
+  VALUE c_Device = rb_const_get(m_Phidget, rb_intern("Device"));
+
+ 	VALUE c_Accelerometer = rb_define_class_under(m_Phidget, "Accelerometer", c_Device);
+
+  /*
+   * Document-method: new
+   * call-seq:
+   *   new(serial_number)
+   *
+   * All phidget objects are created from the device serial number. Serial numbers
+   * are required to be Fixnums (aka "unsigned integers").
+   */
+  rb_define_method(c_Accelerometer, "initialize", accelerometer_initialize, 1);
+
+}
+
+VALUE accelerometer_initialize(VALUE self, VALUE serial) {
+  PhidgetInfo *info = device_info(self);
+
+  CPhidgetAccelerometerHandle accelerometer = 0;
+  ensure(CPhidgetAccelerometer_create(&accelerometer));
+
+  info->handle = (CPhidgetHandle)accelerometer;
+  return rb_call_super(1, &serial);
+}

data/ext/phidgets_native/advancedservo_ruby.c

@@ -0,0 +1,33 @@
+#include "phidgets_native.h"
+
+/* 
+ * Document-class: PhidgetsNative::AdvancedServo < PhidgetsNative::Device
+ *
+ * This class is a stub, and is currently in need of an actual implementation.
+ * Nonetheless, all of the methods from its parent class PhidgetsNative::Device are 
+ * available.
+ */
+
+void Init_phidgets_native_advancedservo(VALUE m_Phidget) {
+  VALUE c_Device = rb_const_get(m_Phidget, rb_intern("Device"));
+
+ 	VALUE c_AdvancedServo = rb_define_class_under(m_Phidget, "AdvancedServo", c_Device);
+
+  /*
+   * Document-method: new
+   * call-seq:
+   *   new(serial_number)
+   *
+   * All phidget objects are created from the device serial number. Serial numbers
+   * are required to be Fixnums (aka "unsigned integers").
+   */
+  rb_define_method(c_AdvancedServo, "initialize", advancedservo_initialize, 1);
+}
+
+VALUE advancedservo_initialize(VALUE self, VALUE serial) {
+  PhidgetInfo *info = device_info(self);
+  CPhidgetAdvancedServoHandle advancedservo = 0;
+  ensure(CPhidgetAdvancedServo_create(&advancedservo));
+  info->handle = (CPhidgetHandle)advancedservo;
+  return rb_call_super(1, &serial);
+}

data/ext/phidgets_native/analog_ruby.c

@@ -0,0 +1,34 @@
+#include "phidgets_native.h"
+
+/* 
+ * Document-class: PhidgetsNative::Analog < PhidgetsNative::Device
+ *
+ * This class is a stub, and is currently in need of an actual implementation.
+ * Nonetheless, all of the methods from its parent class PhidgetsNative::Device are 
+ * available.
+ */
+
+void Init_phidgets_native_analog(VALUE m_Phidget) {
+  VALUE c_Device = rb_const_get(m_Phidget, rb_intern("Device"));
+
+ 	VALUE c_Analog = rb_define_class_under(m_Phidget, "Analog", c_Device);
+
+  /*
+   * Document-method: new
+   * call-seq:
+   *   new(serial_number)
+   *
+   * All phidget objects are created from the device serial number. Serial numbers
+   * are required to be Fixnums (aka "unsigned integers").
+   */
+  rb_define_method(c_Analog, "initialize", analog_initialize, 1);
+}
+
+
+VALUE analog_initialize(VALUE self, VALUE serial) {
+  PhidgetInfo *info = device_info(self);
+  CPhidgetAnalogHandle analog = 0;
+  ensure(CPhidgetAnalog_create(&analog));
+  info->handle = (CPhidgetHandle)analog;
+  return rb_call_super(1, &serial);
+}

data/ext/phidgets_native/bridge_ruby.c

@@ -0,0 +1,32 @@
+#include "phidgets_native.h"
+
+/* 
+ * Document-class: PhidgetsNative::Bridge < PhidgetsNative::Device
+ *
+ * This class is a stub, and is currently in need of an actual implementation.
+ * Nonetheless, all of the methods from its parent class PhidgetsNative::Device are 
+ * available.
+ */
+void Init_phidgets_native_bridge(VALUE m_Phidget) {
+  VALUE c_Device = rb_const_get(m_Phidget, rb_intern("Device"));
+
+ 	VALUE c_Bridge = rb_define_class_under(m_Phidget, "Bridge", c_Device);
+
+  /*
+   * Document-method: new
+   * call-seq:
+   *   new(serial_number)
+   *
+   * All phidget objects are created from the device serial number. Serial numbers
+   * are required to be Fixnums (aka "unsigned integers").
+   */
+  rb_define_method(c_Bridge, "initialize", bridge_initialize, 1);
+}
+
+VALUE bridge_initialize(VALUE self, VALUE serial) {
+  PhidgetInfo *info = device_info(self);
+  CPhidgetBridgeHandle bridge = 0;
+  ensure(CPhidgetBridge_create(&bridge));
+  info->handle = (CPhidgetHandle)bridge;
+  return rb_call_super(1, &serial);
+}

data/ext/phidgets_native/device.c

@@ -0,0 +1,68 @@
+#include "phidgets_native.h"
+
+PhidgetInfo *device_info(VALUE self) {
+  PhidgetInfo *info;
+  Data_Get_Struct( self, PhidgetInfo, info );
+
+  return info;
+}
+
+void *device_type_info(VALUE self) {
+  PhidgetInfo *info;
+  Data_Get_Struct( self, PhidgetInfo, info );
+
+  return info->type_info;
+}
+
+int CCONV device_on_attach(CPhidgetHandle phid, void *userptr)
+{
+  int serialNo;
+  report(CPhidget_getSerialNumber(phid, &serialNo));
+
+  // Populate our data structures with what we know about this device:
+  PhidgetInfo *info = userptr;
+  info->is_attached = true;
+  
+  gettimeofday(&info->attached_at, &info->attached_at_tz);
+
+  // Phidget Attributes:
+  report(CPhidget_getDeviceType(phid, &info->type));
+  report(CPhidget_getDeviceVersion(phid, &info->version));
+  report(CPhidget_getDeviceClass(phid, &info->device_class));
+  report(CPhidget_getDeviceID(phid, &info->device_id));
+  report(CPhidget_getDeviceLabel(phid, &info->label));
+  report(CPhidget_getDeviceName(phid, &info->name));
+
+  return (info->on_type_attach) ? (*info->on_type_attach)(phid, info) : 0;
+}
+
+int CCONV device_on_detach(CPhidgetHandle phid, void *userptr) {
+  int serialNo;
+  report(CPhidget_getSerialNumber(phid, &serialNo));
+
+  PhidgetInfo *info = userptr;
+  info->is_attached = false;
+
+  return (info->on_type_detach) ? (*info->on_type_detach)(phid, info) : 0;
+}
+
+int CCONV device_on_error(CPhidgetHandle phid, void *userptr, int ErrorCode, const char *unknown) {
+  CPhidget_log(PHIDGET_LOG_ERROR, "N/A", "PhidgetNative OnError: %s", unknown);
+  return 0;
+}
+
+void device_free(PhidgetInfo *info) {
+  if (info) {
+    if (info->handle) {
+	    report(CPhidget_close((CPhidgetHandle)info->handle));
+	    report(CPhidget_delete((CPhidgetHandle)info->handle));
+    }
+
+    if (info->on_type_free)
+      (*info->on_type_free)(info->type_info);
+
+    if (info)
+      xfree(info);
+  }
+}
+