littlewire 0.9

data/examples/blinky.rb

@@ -0,0 +1,16 @@
+# A little blinky test to show how to make stuff happen with a littlewire in ruby!
+#
+# To get started, plug an LED in to the ISP cable between ground and Pin 4 (they're next to each other)
+require '../lib/littlewire.rb'
+
+wire = LittleWire.connect
+
+# set pin4 to an input, so our LED doesn't burn out without a resistor
+wire.pin_mode :pin4 => :input
+
+loop do
+  wire.digital_write(:pin4, true) # set the LED on for half a second
+  sleep 0.5
+  wire.digital_write(:pin4, false) # set the LED off for half a second
+  sleep 0.5
+end

data/examples/fadey.rb

@@ -0,0 +1,22 @@
+# A little blinky test to show how to make stuff happen with a littlewire in ruby!
+#
+# To get started, plug an LED in to the ISP cable between ground and Pin 4 (they're next to each other) via a resistor (resistor not optional)
+require '../lib/littlewire.rb'
+
+wire = LittleWire.connect
+
+FPS = 60 # update 60 times per second
+fader = 0.0 # our current position
+
+loop do
+  value = (Math.sin(fader) + 1.0) * 127.0 # calculate an ideal brightness
+  
+  ## Some equivilent ways of expressing this idea:
+  # wire.software_pwm_write(:softpwm_a, value)
+  # wire[:softpwm_a] = value
+  # wire[:softpwm_1] = value
+  wire.softpwm_a = value
+  
+  fader += 0.025
+  sleep 1.0 / FPS
+end

data/lib/analog.rb

@@ -0,0 +1,33 @@
+module LittleWire::Analog
+  # Read the current value of an analog input
+  # Valid inputs are 
+  AnalogReferences = [:vcc, :internal_reference_1_1, :internal_reference_2_56]
+  def analog_read input_name, voltage_reference = :vcc
+    voltage_reference = AnalogReferences.index(voltage_reference) if AnalogReferences.include? voltage_reference
+    scaling_setting = 0x07
+    
+    if @analog_reference != voltage_reference
+      @analog_reference = voltage_reference
+      # This reset step is to work around a bug in firmware 1.1 - hopefully it can be disabled in future releases
+      control_transfer(function: :analog_init, wValue: scaling_setting) # reset analog reference setting
+      # set new reference voltage
+      control_transfer(function: :analog_init, wValue: scaling_setting | voltage_reference << 8)
+    end
+    
+    control_transfer(function: :read_adc,
+                       wValue: get_pin(AnalogPinMap, input_name),
+                       dataIn: 2).unpack('S<').first / 1024.0
+  end
+  
+  # Get the current temperature inside the LittleWire device's microcontroller. At a courseness of about 1.1°C increments
+  # and quite a lot of noise in the measurements, some averaging is required. Rather neatly, because of the noise in each
+  # sample, when averaged you get higher than 1.1°C resolution.
+  #
+  # This method returns a value around 280.0 - you'll need to calibrate it yourself by simple subtraction. You can calibrate
+  # it even more accurately by linearly mapping it to two known temperature points. Each LittleWire is a bit different so some
+  # calibration is necessary (unless you just want to take relative measurements).
+  def temperature
+    (analog_read(:temperature, :internal_reference_1_1) * 1024.0) / 1.12
+  end
+  
+end

data/lib/digital.rb

@@ -0,0 +1,110 @@
+module LittleWire::Digital
+  EnableBulkWrite = false # this thing seems to not work good - not ready for real world use
+  # these firmwares have a default state specified, enabling bulk writing
+  BulkWriteDefaultStates = { '1.1' => 0b00001000 } # D- usb bit is high, others are low
+  BulkWriteBitmask =       { '1.1' => 0b00100111 }
+  
+  # Write one or more digital values to device pins
+  # 
+  # A simple invokation is `my_wire.digital_write(:pin1, true)` setting pin1 to a
+  # high logic level. :high and :low can be substituted for true and false, as can
+  # :on and :off, :vcc and :gnd or :ground
+  #
+  # `digital_write` can also be called with a hash: `my_wire.digital_write(:pin1 => true)`
+  # allowing multiple pins to be set at once. A system for updating all pins simultaniously is being
+  # worked on, but is not yet stable, so for now digital_write uses a request for each pin.
+  #
+  # Automatically disables PWM and Servo features if you try to write to a pin used by those modules
+  def digital_write *args
+    if args.length > 1
+      self.digital_write({args[0] => args[1]})
+    else
+      raise "Incorrect Arguments" unless args.first.respond_to? :to_hash
+      hash = args.first.to_hash
+      
+      #self.hardware_pwm_enabled = false if hash.keys.any? { |pin| LittleWire::HardwarePWMPinMap.has_key? pin }
+      #self.software_pwm_enabled = false if hash.keys.any? { |pin| LittleWire::SoftwarePWMPinMap.has_key? pin }
+      
+      if use_experimental_bulk_write?
+        # could cause problems - must do tests when deciding if to enable this or not
+        @bulk_write_bitmap ||= 0
+        
+        hash.each do |pin, state|
+          if get_boolean(state)
+            @bulk_write_bitmap |= 1 << get_pin(LittleWire::DigitalPinMap, pin)
+          else
+            @bulk_write_bitmap &= ~(1 << get_pin(LittleWire::DigitalPinMap, pin))
+          end
+        end
+        value = (@bulk_write_bitmap & BulkWriteBitmask[self.version]) | BulkWriteDefaultStates[self.version]
+        control_transfer(function: :write, wValue: value)
+      else
+        hash.each do |pin, state|
+          control_transfer(
+            function: get_boolean(state) ? :pin_set_high : :pin_set_low,
+            wValue: get_pin(LittleWire::DigitalPinMap, pin)
+          )
+        end
+      end
+    end
+  end
+  
+  # Read one or more digital values from device pins
+  #
+  # The simplest invocation is `my_wire.digital_read(:pin1)`, returning a true or false
+  # where true is a high (positive) voltage and false is a lower (near ground) voltage
+  #
+  # A more advanced invokation is passing several pins as arguments or an array of pins
+  # `sensor_a, sensor_b = my_wire.digital_read(:pin1, :pin2)` which reads both pins at
+  # the exact same instant in just one USB request, returning an array of the results
+  #
+  # digital_read tends to work best when the pin in :input mode. See also #pin_mode
+  def digital_read *args
+    raise "Incorrect Arguments" if args.length < 1
+    pins = args.flatten
+    port = control_transfer(function: :read, dataIn: 1).unpack('c').first
+    mapped = pins.map do |pin|
+      pin = get_pin(LittleWire::DigitalPinMap, pin)
+      (port & pin) != 0 # discover if pin is high or low
+    end
+    
+    if args.length == 1 and (args.first.is_a?(Symbol) or args.first.is_a?(Integer))
+      mapped.first
+    else
+      mapped
+    end
+  end
+  
+  # Set the mode of one or more device pins
+  #
+  # A simple form is `my_wire.pin_mode(:pin1, :input)` setting pin1 to input mode.
+  # Multiple pins can be set using `my_wire.pin_mode(:pin1 => :input, :pin2 => :output)`
+  # 
+  # :input mode leaves the pin disconnected if `digital_write`n to false, or connected
+  # via a 20kohm resistor to 5 volts if `digital_write`n to true.
+  #
+  # :output mode connects the pin directly to 5 volts when `digital_write`n to true
+  # and connects it to ground when digitally written to false. Be careful not to create
+  # short circuits as these may damage your LittleWire.
+  def pin_mode *args
+    if args.length == 2
+      self.pin_mode( args[0] => args[1] )
+    else
+      raise if args.length != 1 or !args.first.is_a?(Hash)
+      
+      modes = {
+        :input => :pin_set_input, :in => :pin_set_input,
+        :output => :pin_set_output, :out => :pin_set_output
+      }
+      args.first.each do |pin, mode|
+        raise "Unknown mode #{mode.inspect}" unless modes[mode.to_sym]
+        control_transfer(function: modes[mode.to_sym], wValue: get_pin(LittleWire::DigitalPinMap, pin))
+      end
+    end
+  end
+  
+  private
+  def use_experimental_bulk_write?
+    EnableBulkWrite and BulkWriteDefaultStates.include?(self.version.to_s)
+  end
+end

data/lib/hardware-pwm.rb

@@ -0,0 +1,53 @@
+module LittleWire::HardwarePWM
+  attr_reader :hardware_pwm_enabled # initially :unknown, then a boolean
+  
+  # Set hardware pwm as enabled or disabled - hardware pwm is automatically enabled when you start using it
+  # but must be disabled before using these pins again for other purposes
+  def hardware_pwm_enabled= value
+    return if @hardware_pwm_enabled == value
+    @hardware_pwm_enabled = !!value
+    control_transfer(function: value ? :start_pwm : :stop_pwm)
+  end
+  
+  # Get an array of the current values in the Hardware PWM module
+  def hardware_pwm; @hardware_pwm.dup; end
+  
+  # Set Hardware PWM to an array of new values - array must be two items long
+  def hardware_pwm= values
+    self.hardware_pwm_enabled = true
+    @hardware_pwm[0] = values[0].to_i % 256
+    @hardware_pwm[1] = values[1].to_i % 256
+    control_transfer(function: :update_pwm_compare, wValue: @hardware_pwm[0].to_i, wIndex: @hardware_pwm[1].to_i)
+  end
+  
+  # Get the current value of a Hardware PWM channel (stored in littlewire.rb library - not requested from device)
+  def hardware_pwm_read channel; hardware_pwm[get_pin(LittleWire::HardwarePWMPinMap, channel)]; end
+  
+  # Set an individual Hardware PWM channel to a new value in the range of 0-255
+  def hardware_pwm_write channel, value
+    updated = self.hardware_pwm
+    updated[get_pin(LittleWire::HardwarePWMPinMap, channel)] = value
+    self.hardware_pwm = updated
+  end
+  
+  
+  PWMPrescaleSettings = [1, 8, 64, 256, 1024] # :nodoc:
+  # Set division of the Hardware PWM Prescaler - default 1024. This setting controls how quickly LittleWire's PWM channels oscillate
+  # between their 'high' and 'low' state. Lower prescaler values are often nicer for lighting, while higher values can be better for
+  # motor speed control and 1024 is required for servo position control
+  #     1024: roughly 63hz
+  #     256: roughly 252hz
+  #     64: roughly 1khz
+  #     8: roughly 8khz
+  #     1: roughly 64khz
+  #
+  # No other values are accepted
+  def hardware_pwm_prescale= division
+    raise "Unsupported Hardware PWM Prescale value, must be #{PWMPrescaleSettings.inspect}" unless PWMPrescaleSettings.include? division
+    if @hardware_pwm_prescale != division
+      @hardware_pwm_prescale = division
+      control_transfer(function: :change_pwm_prescale, wValue: PWMPrescaleSettings.index(division))
+    end
+  end
+
+end

data/lib/i2c.rb

@@ -0,0 +1,43 @@
+class LittleWire::I2C
+  def initialize wire
+    @wire = wire
+    @wire.control_transfer(function: :i2c_init)
+  end
+  
+  # start an i2c message
+  #
+  # Arguments:
+  #   address: (Integer) 7 bit numeric address
+  #   direction: (Symbol) :in or :out
+  def start address_7bit, direction
+    direction = 1 if direction == :out || direction == :output || direction == :write
+    direction = 0 if direction != 1
+    config = (address_7bit.to_i << 1) | direction
+    @wire.control_transfer(function: :i2c_begin, wValue: config)
+    @wire.control_transfer(function: :read_buffer, dataIn: 8).bytes.first != 0
+  end
+  
+  # read bytes from i2c device, optionally ending with a stop when finished
+  def read length, endWithStop = false
+    @wire.control_transfer(function: :i2c_read, wValue: (length.to_i & 0xFF) << 8 | (endWithStop ? 1 : 0))
+    @wire.control_transfer(function: :read_buffer, dataIn: 8)[0...length.to_i]
+  end
+  
+  # write data to i2c device, optionally sending a stop when finished
+  def write send_buffer, end_with_stop = false
+    send_buffer = send_buffer.pack('c*') if send_buffer.is_a? Array
+    raise "Send buffer is too long" if send_buffer.length > 7
+    
+    # TODO: Send multiple requests to handle send buffers longer than 7 bytes
+    @wire.control_transfer(
+      wRequest: 0xE0 | send_buffer.length | (end_with_stop << 3),
+      wValue: (send_buffer.bytes[1] << 8) + send_buffer.bytes[0],
+      wIndex: (send_buffer.bytes[3] << 8) + send_buffer.bytes[2]
+    )
+  end
+  
+  # set the update delay of LittleWire's i2c module
+  def delay= update_delay
+    @wire.control_transfer(function: :i2c_update_delay, wValue: update_delay.to_i)
+  end
+end

data/lib/littlewire.rb

@@ -0,0 +1,302 @@
+# A little library for a little wire, by Bluebie
+# Provides an arduino or wiring style interface to the LittleWire device's IO features
+# and provides a nicer invented ruby-style interface also.
+require 'libusb'
+class LittleWire; end
+require_relative 'digital'
+require_relative 'analog'
+require_relative 'hardware-pwm'
+require_relative 'software-pwm'
+require_relative 'servo'
+require_relative 'spi'
+require_relative 'i2c'
+require_relative 'one-wire'
+
+# LittleWire class represents LittleWire's connected to your computer via USB
+# 
+# Most of the time you'll only have one LittleWire - in this case, use LittleWire.connect to get
+# ahold of your wire. If you have more than one, you can use LittleWire.all to fetch an array of them
+class LittleWire
+  include Digital
+  include Analog
+  include HardwarePWM
+  include SoftwarePWM
+  include Servo
+  
+  # pin name to numeric internal code maps
+  DigitalPinMap = { # maps common names to bit positions in PORTB
+    pin1: 1, d1: 1, miso:  1, pwm_b: 1, pwm_2: 1,
+    pin2: 2, d2: 2, sck:   2,
+    pin3: 5, d3: 5, reset: 5,
+    pin4: 0, d4: 0, mosi:  0, pwm_a: 0, pwm_1: 0 }
+  AnalogPinMap = { # maps common names to switch index in littlewire firmware
+    a1: 0, adc_1: 0, reset: 0, pin3: 0, d3: 0,
+    a2: 1, adc_2: 1, sck:   1, pin2: 1, d2: 1,
+    temperature: 2, temp: 2 }
+  HardwarePWMPinMap = { # maps common pin names to @hardware_pwm array index
+    pwm_b: 1, pwm_1: 1, d1: 1, pin1: 1, miso: 1,
+    pwm_a: 0, pwm_2: 0, d4: 0, pin4: 0, mosi: 0 }
+  SoftwarePWMPinMap = { # TODO: figure out which pins these are
+    softpwm_1: 0, softpwm_a: 0, 
+    softpwm_2: 1, softpwm_b: 1,
+    softpwm_3: 2, softpwm_c: 2 }
+  GenericPinMap = { # generic pinmap used by [] and []= methods to refer to anything
+    d1: [:digital, :pin1],
+    d2: [:digital, :pin2],
+    d3: [:digital, :pin3],
+    d4: [:digital, :pin4],
+    pin1: [:digital, :pin1],
+    pin2: [:digital, :pin2],
+    pin3: [:digital, :pin3],
+    pin4: [:digital, :pin4],
+    a1: [:analog, :a1],
+    a2: [:analog, :a2],
+    adc_1: [:analog, :adc_1],
+    adc_1: [:analog, :adc_2],
+    pwm_1: [:hardware_pwm, :pwm_1],
+    pwm_2: [:hardware_pwm, :pwm_2],
+    pwm_a: [:hardware_pwm, :pwm_a],
+    pwm_b: [:hardware_pwm, :pwm_b],
+    softpwm_1: [:software_pwm, :softpwm_1],
+    softpwm_2: [:software_pwm, :softpwm_2],
+    softpwm_3: [:software_pwm, :softpwm_3],
+    softpwm_a: [:software_pwm, :softpwm_a],
+    softpwm_b: [:software_pwm, :softpwm_b],
+    softpwm_c: [:software_pwm, :softpwm_c],
+  }
+  
+  SupportedVersions = ['1.1', '1.0'] # in order of newness. # TODO: Add version 1.0?
+  
+  
+  # An array of all unclaimed littlewires connected to computer via USB
+  def self.all
+    usb = LIBUSB::Context.new
+    usb.devices.select { |device|
+      device.idProduct == 0x0c9f && device.idVendor == 0x1781 && device.product == 'USBtinySPI'
+    }.map { |device|
+      self.new(device)
+    }
+  end
+  
+  # Frst littlewire connected to this computer via USB - good when you only have one
+  def self.connect; all.first; end
+  
+  
+  # initializes a LittleWire with a libusb device reference and some default values - does not talk to device
+  def initialize devref #:nodoc:
+    @device = devref
+    
+    @hardware_pwm_enabled = :unknown
+    @hardware_pwm_prescale = :unknown
+    @hardware_pwm = [0, 0]
+    @software_pwm_enabled = :unknown
+    @software_pwm = [0, 0, 0]
+    
+    # shut everything down, trying to setup littlewire in consistent initial state in case previous programs
+    # messed with it's state
+    self.software_pwm_enabled = false
+    self.hardware_pwm_enabled = false
+    self.pin_mode(pin1: :input, pin2: :input, pin3: :input, pin4: :input)
+    self.digital_write(pin1: :gnd, pin2: :gnd, pin3: :gnd, pin4: :gnd)
+  end
+  
+  # creates a lambda to close usb device when LittleWire is deallocated, without LittleWire instance closured in to it recursively
+  def self.create_destructor io #:nodoc:
+    lambda do
+      io.close
+    end
+  end
+  
+  # Call finished when you're done with the LittleWire to release it for other programs to use. You can always claim it again
+  # later by using any of the methods on this class which communicate over USB
+  def finished
+    if @io
+      ObjectSpace.undefine_finalizer(self) # remove usb closer finalizer
+      @io.close
+      @io = nil
+    end
+  end
+  
+  
+  # implementations of littlewire functions
+  # - generic requests
+  def echo; control_transfer(function: :echo, dataIn: 8).unpack('S<*'); end # echo's usb request for testing
+  def read; control_transfer(function: :read, wIndex: 0, dataIn: 1); end
+  def write byte; control_transfer(function: :write, wIndex: 0, wValue: byte); end
+  def clear_bit bit; control_transfer(function: :clear_bit, wIndex: 0, wValue: bit); end
+  def set_bit bit; control_transfer(function: :set_bit, wIndex: 0, wValue: bit); end
+  # - programming requests
+  #def power_up sck_period, reset; control_transfer(function: :power_up, wIndex: sck_period, wValue: reset ? 1 : 0); end
+  #def power_down; control_transfer(function: :power_down); end
+  # TODO: maybe spi, poll_bytes, flash_read, flash_write, eprom_read, eeprom_write
+  
+  
+  # returns version code number (treat it as a hex number)
+  def version_hex
+    @version_hex ||= control_transfer(function: :version, dataIn: 1).unpack('c').first
+  end
+  
+  # Returns version number of firmware on LittleWire hardware
+  def version
+    @version ||= version_hex.to_s(16).chars.entries.join('.')
+  end
+  
+  # get the SPI interface
+  def spi
+    @spi ||= SPI.new(self)
+  end
+  
+  # get the I2C interface
+  def i2c
+    @i2c ||= I2C.new(self)
+  end
+  
+  # get the 1wire interface (requires firmware 1.1 or newer
+  def one_wire
+    raise "You need to update your LittleWire firmware to version 1.1 to use One Wire" unless version_hex >= 0x11
+    @one_wire ||= OneWire.new(self)
+  end
+  
+  
+  
+  # translate calls with arduino-style lowerCamelCase method names in to ruby-style underscored_method_names
+  def method_missing name, *args, &proc
+    underscorized = name.to_s.gsub(/([a-z])([A-Z])/) { "#{$1}_#{$2}" }.downcase  # make underscored equivilent
+    return send(underscorized, *args, &proc) if respond_to? underscorized # translate casing style if we can find an equivilent
+    
+    read_only = name.to_s.gsub('=', '').to_sym
+    if GenericPinMap.has_key? read_only
+      if name.to_s.end_with? '='
+        return (self[read_only] = args.first)
+      else
+        return self[read_only]
+      end
+    end
+    
+    super # default behaviour
+  end
+  
+  
+  # get the value of something
+  def [] name
+    pin = GenericPinMap[name.to_sym]
+    raise "Unknown Pin '#{name}'" unless pin
+    self.send "#{pin[0]}_read", pin[1]
+  end
+  
+  # set the value of something
+  def []= name, value
+    pin = GenericPinMap[name.to_sym]
+    raise "Unknown Pin '#{name}'" unless pin
+    self.send "#{pin[0]}_write", pin[1], value
+  end
+  
+  protected
+  # raw opened device
+  def io #:nodoc:
+    unless @io
+      @io = @device.open
+      ObjectSpace.define_finalizer(self, self.class.create_destructor(@io))
+      
+      # check for compatible firmware on littlewire device and warn if is unknown
+      warn "Unknown littlewire.cc firmware version #{version} might cause problems" unless SupportedVersions.include? version
+    end
+    @io
+  end
+  
+  # functions offered by the LittleWire
+  Functions = [
+    ## Generic requests
+    :echo,      # echo test  0
+    :read,      # read byte (wIndex:address)  1
+    :write,     # write byte (wIndex:address, wValue:value)  2
+    :clear_bit, # clear bit (wIndex:address, wValue:bitno)  3
+    :set_bit,   # set bit (wIndex:address, wValue:bitno)  4
+    ## Programming requests
+    :power_up,      # apply power (wValue:SCK-period, wIndex:RESET)  5
+    :power_down,    # remove power from chip  6
+    :spi,           # issue SPI command (wValue:c1c0, wIndex:c3c2)  7
+    :poll_bytes,    # set poll bytes for write (wValue:p1p2)  8
+    :flash_read,    # read flash (wIndex:address)  9
+    :flash_write,   # write flash (wIndex:address, wValue:timeout)  10
+    :eeprom_read,   # read eeprom (wIndex:address)  11
+    :eeprom_write,  # write eeprom (wIndex:address, wValue:timeout)  12
+    ## Additional requests - ihsanKehribar
+    :pin_set_input,       # 13
+    :pin_set_output,      # 14
+    :read_adc,            # 15
+    :start_pwm,           # 16
+    :update_pwm_compare,  # 17
+    :pin_set_high,        # 18
+    :pin_set_low,         # 19
+    :pin_read,            # 20
+    :single_spi,          # 21
+    :change_pwm_prescale, # 22
+    :setup_spi,           # 23
+    :setup_i2c,           # 24
+    :i2c_begin_tx,        # 25
+    :i2c_add_buffer,      # 26
+    :i2c_send_buffer,     # 27
+    :spi_add_buffer,      # 28
+    :spi_send_buffer,     # 29
+    :i2c_request_from,    # 30
+    :spi_update_delay,    # 31
+    :stop_pwm,            # 32
+    :debug_spi,           # 33
+    :version,             # 34
+    :analog_init,         # 35
+    :reserved, :reserved, :reserved, :reserved,
+    :read_buffer,         # 40
+    :onewire_reset_pulse, # 41
+    :onewire_send_byte,   # 42
+    :onewire_read_byte,   # 43
+    :i2c_init,            # 44
+    :i2c_begin,           # 45
+    :i2c_read,            # 46
+    :init_softpwm,        # 47
+    :update_softpwm,      # 48
+    :i2c_update_delay,    # 49
+    :onewire_read_bit,    # 50
+    :onewire_write_bit,   # 51
+    :pic_24f_programming, # 52 - experimental
+    :pic_24f_sendsix      # 53 - experimental
+    # special cases
+    # pic 24f send bytes - request = 0xD*
+    # i2c send multiple messages - request = 0xE*     ### experimental ###
+    # spi multiple message send - request = 0xF*
+  ]
+  # transfer data between usb device and this program
+  def control_transfer(opts = {}) #:nodoc:
+    opts[:bRequest] = Functions.index(opts.delete(:function)) if opts[:function]
+    io.control_transfer({
+      wIndex: 0,
+      wValue: 0,
+      bmRequestType: usb_request_type(opts),
+      timeout: 5000
+    }.merge opts)
+  end
+  
+  # calculate usb request type
+  def usb_request_type opts #:nodoc:
+    c = LIBUSB::Call
+    value = c::RequestTypes[:REQUEST_TYPE_VENDOR] | c::RequestRecipients[:RECIPIENT_DEVICE]
+    value |= c::EndpointDirections[:ENDPOINT_OUT] if opts.has_key? :dataOut
+    value |= c::EndpointDirections[:ENDPOINT_IN] if opts.has_key? :dataIn
+    return value
+  end
+  
+  
+  # lookup a pin name in a map and return it's raw identifier
+  def get_pin map, value #:nodoc:
+    value = value.to_sym if value.is_a? String
+    value = map[value] if map.has_key? value
+    value
+  end
+  
+  # translate possible literal values in to a boolean true or false (meaning high or low)
+  def get_boolean value #:nodoc:
+    # some exceptions
+    value = false if value == :low or value == 0 or value == nil or value == :off or value == :ground or value == :gnd
+    !! value # double invert value in to boolean form
+  end
+end

data/lib/one-wire.rb

@@ -0,0 +1,6 @@
+module LittleWire::OneWire
+  def initialize wire
+    @wire = wire
+    raise "One Wire not yet implemented in ruby library"
+  end
+end

data/lib/servo.rb

@@ -0,0 +1,18 @@
+module LittleWire::Servo
+  # Get the current andle of a servo connected to a hardware pwm channel as an angle between roughly -90° and +90°
+  def servo_read hardware_pwm_channel
+    value = hardware_pwm_read(hardware_pwm_channel)
+    90 - ((value - 13).to_f * (180.0 / 23.0))
+  end
+  
+  # Set a servo connected to a hardware pwm channel to an angle between -90° and +90° inclusive
+  # Note that setting a servo's position automatically enables Hardware PWM - disable hardware pwm when you're done
+  # if you want to use these pins for something else
+  def servo_write hardware_pwm_channel, angle
+    self.hardware_pwm_prescale = 1024 # make sure our PWM is running at the correct frequency
+    
+    value = ((angle + 90.0) / (180.0 / 23.0)).round + 13
+    
+    hardware_pwm_write(hardware_pwm_channel, value)
+  end
+end

data/lib/software-pwm.rb

@@ -0,0 +1,51 @@
+# Interface to LittleWire 1.1's software pwm feature
+module LittleWire::SoftwarePWM
+  # Has the software pwm module been enabled?
+  attr_reader :software_pwm_enabled
+  
+  # Set if the software pwm module is enabled or inactive
+  def software_pwm_enabled= value
+    value = !! value # booleanify it
+    if @software_pwm_enabled != value
+      require_software_pwm_available
+      control_transfer(function: :init_softpwm, wValue: value ? 1 : 0)
+      @software_pwm_enabled = value
+    end
+  end
+  
+  # An array of current software pwm values
+  def software_pwm; @software_pwm.dup; end
+  
+  # Set software pwm to the values of an array - values must be a number between 0 and 255 inclusive
+  def software_pwm= values
+    require_software_pwm_available
+    self.software_pwm_enabled = true
+    
+    3.times do |idx|
+      @software_pwm[idx] = values[idx].to_i % 256
+    end
+    
+    control_transfer(function: :update_softpwm, wValue: @software_pwm[1] << 8 | @software_pwm[0], wIndex: @software_pwm[2])
+  end
+  
+  # Get the value of a single software pwm channel
+  def software_pwm_read channel
+    @software_pwm[get_pin(LittleWire::SoftwarePWMPinMap, channel)]
+  end
+  
+  # Set the value of a single software pwm channel - value must be a number between 0 and 255 inclusive
+  def software_pwm_write channel, value
+    state = self.software_pwm
+    state[get_pin(LittleWire::SoftwarePWMPinMap, channel)] = value
+    self.software_pwm = state
+  end
+  
+  def is_software_pwm_available?
+    version_hex >= 0x11
+  end
+  
+  private
+  def require_software_pwm_available
+    raise "Software PWM not available in version #{self.version} firmware" unless is_software_pwm_available?
+  end
+end

data/lib/spi.rb

@@ -0,0 +1,28 @@
+class LittleWire::SPI
+  def initialize wire
+    @wire = wire
+    @wire.control_transfer(function: :setup_spi)
+    raise "SPI requires LittleWire firmware 1.1. Yours = #{@wire.version}" unless @wire.version_hex >= 0.11
+  end
+  
+  # send and receive a message of up to four bytes
+  def send send, receive, auto_chipselect = false
+    mode = auto_chipselect ? 1 : 0
+    @wire.control_transfer(
+      wRequest: 0xF0 + send.length + (mode << 3),
+      wValue: send.bytes[1] << 8 | send.bytes[0],
+      wIndex: send.bytes[3] << 8 | send.bytes[0]
+    )
+  end
+  
+  # change spi delay setting
+  def delay= number
+    @wire.control_transfer(function: :spi_update_delay, wValue: number)
+  end
+  
+  # get debug status
+  def debug
+    @wire.control_transfer(function: :debug_spi, dataIn: 8)
+    @wire.control_transfer(function: :read_buffer, dataIn: 8).unpack('c').first
+  end
+end

data/license.txt

@@ -0,0 +1 @@
+I give this code to you, dear reader. Do what you like with it. It's none of my concern! — Bluebie

data/readme.md

@@ -0,0 +1,68 @@
+Little Wire is a little multiheaded animal who pokes in a USB port, and uploads
+programs to AVR and PIC chips. But Little Wire does so much more - and that's
+what this library is about. The [littlewire.cc](http://littlewire.cc/) gadget
+exposes four digital wires and a five volt power supply. Those four wires can
+each be individually controlled, with three capable of varying brightness of
+lights, two capable of controlling motors and servos, two 10-bit analog inputs,
+a temperature sensor, a Serial Peripheral Interface, an i2c interface, and a
+1-wire interface.
+
+Eventually littlewire.rb hopes to share fun, simple, principal of least surprise
+ruby interfaces to all of these.
+
+
+### a blinky ###
+
+    require 'littlewire'
+    
+    wire = LittleWire.connect # connects to the first Little Wire on your computer
+    
+    loop do
+      wire.digital_write :pin3, :vcc # connect pin3 to 5v
+      sleep 0.5
+      wire.digital_write :pin3, :gnd # connect pin3 to ground
+      sleep 0.5
+    end
+
+And so it is that the ruby on the computer did remotely control the Little Wire's
+digital port. Don't forget a resistor for that LED of yours! If you don't have a
+resistor handy, add `wire.pin_mode :pin3 => :input` before `loop do` to use
+Little Wire's internal 20kohm resistor and keep that light shining.
+
+
+### a philosophy ###
+
+Little Wire is such a small creature it's possible perhaps to implement every way
+you might want to use it! Every method name and every symbol. I've tried to do this
+a bit. My hope is that you'll play with littlewire in irb (or better yet 
+[pry](http://pryrepl.org)) and everything you try just works. To that end, littlewire
+supports `ruby_style_methods` and `wiringStyleMethods`, and has methods like
+`digitalWrite(:pin1, true)` - familliar to arduinoers but also syntaxes like
+`mywire[:d1] = true`. Initialization sequences automatically run the moment you try
+to use features, and they always try to make sure littlewire is correctly configured
+for the task at hand, while not making any unnecessary requests. The only thing
+littlewire.rb doesn't do (yet) is program other chips - use avrdude for that.
+
+
+### what's it good for? ###
+
+You could use the three pulse width modulated analog outputs to control an RGB light
+adjusting the mood of your batcave at the click of a button. Hook it up to displays,
+memory, sensors, iButtons, RFID readers, digital radios, motors, switches, fairy
+lights... whatever floats your boat really. The possabilities are not especially
+limited. Most projects you might use an Arduino for can be done with a Little Wire
+if you don't mind leaving a computer turned on connected to it, and with the advent
+of Raspberry Pi, that's not all that bad of an idea. I use my Little Wire to quickly
+test ideas before changing them to C and uploading them to cheaper attiny chips (also
+using the Little Wire to program them)
+
+
+### a warning ###
+
+littlewire.rb is experimental (till it is released as 1.0 via rubygems) and there's
+a pretty good chance the API will change a bit until then. Not to worry - rubygems
+have a mechanism for you to [require a specific version][1] of littlewire.rb,
+ensuring your programs always work, so you can start building stuff on it today!
+
+[1]: http://docs.rubygems.org/read/chapter/4#page71 "RubyGems Documentation"
+

metadata

@@ -0,0 +1,79 @@
+--- !ruby/object:Gem::Specification
+name: littlewire
+version: !ruby/object:Gem::Version
+  version: '0.9'
+  prerelease: 
+platform: ruby
+authors:
+- Bluebie
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: libusb
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+description: A little library for a little wire. Providing a pure ruby interface (via
+  the nonpure libusb gem) to littlewire.cc's wonderful gadget. littlewire.rb provides
+  general purpose digital IO, pulse width modulation analog outputs, analog inputs,
+  SPI, I2C, One Wire, and rough servo control via a friendly interface which responds
+  both to familliar Wiring/Arduino style methods and a more concise ruby alternative.
+email: a@creativepony.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/analog.rb
+- lib/digital.rb
+- lib/hardware-pwm.rb
+- lib/i2c.rb
+- lib/littlewire.rb
+- lib/one-wire.rb
+- lib/servo.rb
+- lib/software-pwm.rb
+- lib/spi.rb
+- readme.md
+- license.txt
+- examples/blinky.rb
+- examples/fadey.rb
+homepage: http://creativepony.com/littlewire/
+licenses: []
+post_install_message: 
+rdoc_options:
+- --main
+- lib/littlewire.rb
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.21
+signing_key: 
+specification_version: 3
+summary: A tiny library for littlewire.cc usb devices
+test_files: []