littlewire 0.9.7 → 0.9.8

data/lib/littlewire.rb

@@ -1,18 +1,20 @@
-# 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'
-require_relative 'ws2811'
+require_relative 'littlewire/digital'
+require_relative 'littlewire/analog'
+require_relative 'littlewire/hardware-pwm'
+require_relative 'littlewire/software-pwm'
+require_relative 'littlewire/servo'
+require_relative 'littlewire/spi'
+require_relative 'littlewire/i2c'
+require_relative 'littlewire/one-wire'
+require_relative 'littlewire/ws2811'
+require_relative 'littlewire/version'
 
+# 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.
+# 
 # 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
@@ -66,7 +68,7 @@ class LittleWire
     softpwm_c: [:software_pwm, :softpwm_c],
   }
   
-  SupportedVersions = ['1.2', '1.1', '1.0'] # in order of newness. # TODO: Add version 1.0?
+  SupportedVersions = ['1.2', '1.1', '1.0'] # in order of newness.
   
   
   # An array of all unclaimed littlewires connected to computer via USB
@@ -95,7 +97,7 @@ class LittleWire
     
     # 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.software_pwm_enabled = false if version_hex >= 0x11
     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)

data/lib/{digital.rb → littlewire/digital.rb}

@@ -81,7 +81,7 @@ module LittleWire::Digital
   # 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.
+  # via a 20kohm resistor to 5 volts if `digital_write` 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

data/lib/littlewire/gadgets/micronucleus.rb

@@ -0,0 +1,171 @@
+require 'libusb'
+
+# Abstracts access to micronucleus avr tiny85 bootloader - can be used only to erase and upload bytes
+class Micronucleus
+  Functions = [
+    :get_info,
+    :write_page,
+    :erase_application,
+    :run_program
+  ]
+
+  # return all micronucleus devices connected to computer
+  def self.all
+    usb = LIBUSB::Context.new
+    usb.devices.select { |device|
+      device.idVendor == 0x16d0 && device.idProduct == 0x0753
+    }.map { |device|
+      self.new(device)
+    }
+  end
+
+  def initialize devref
+    @device = devref
+  end
+
+  def info
+    unless @info
+      result = control_transfer(function: :get_info, dataIn: 4)
+      flash_length, page_size, write_sleep = result.unpack('S>CC')
+
+      @info = {
+        flash_length: flash_length,
+        page_size: page_size,
+        pages: (flash_length.to_f / page_size).ceil,
+        write_sleep: write_sleep.to_f / 1000.0,
+        version: "#{@device.bcdDevice >> 8}.#{(@device.bcdDevice & 0xFF).to_s.rjust(2, '0')}",
+        version_numeric: @device.bcdDevice
+      }
+    end
+
+    @info
+  end
+
+  def erase!
+    puts "erasing"
+    info = self.info
+    control_transfer(function: :erase_application)
+    info[:pages].times do
+      sleep(info[:write_sleep]) # sleep for as many pages as the chip has to erase
+    end
+    puts "erased chip"
+  end
+
+  # upload a new program
+  def program= bytestring
+    info = self.info
+    raise "Program too long!" if bytestring.bytesize > info[:flash_length]
+    bytes = bytestring.bytes.to_a
+    bytes.push(0xFF) while bytes.length < info[:flash_length]
+    
+    erase!
+    
+    address = 0
+    bytes.each_slice(info[:page_size]) do |slice|
+      slice.push(0xFF) while slice.length < info[:page_size] # ensure every slice is one page_size long - pad out if needed
+      
+      puts "uploading @ #{address} of #{bytes.length}"
+      control_transfer(function: :write_page, wIndex: address, wValue: slice.length, dataOut: slice.pack('C*'))
+      sleep(info[:write_sleep])
+      address += slice.length
+    end
+  end
+
+  def finished
+    info = self.info
+
+    puts "asking device to finish writing"
+    control_transfer(function: :run_program)
+    puts "waiting for device to finish"
+
+    # sleep for as many pages as the chip could potentially need to write - this could be smarter
+    info[:pages].times do
+      sleep(info[:write_sleep]) 
+    end
+
+    @io.close
+    @io = nil
+  end
+
+  def inspect
+    "<Micronucleus #{info[:version]}: #{(info[:flash_length] / 1024.0).round(1)} kb programmable>"
+  end
+
+  protected
+  # raw opened device
+  def io
+    unless @io
+      @io = @device.open
+    end
+
+    @io
+  end
+
+  def control_transfer(opts = {})
+    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:
+    value = LIBUSB::REQUEST_TYPE_VENDOR | LIBUSB::RECIPIENT_DEVICE
+    value |= LIBUSB::ENDPOINT_OUT if opts.has_key? :dataOut
+    value |= LIBUSB::ENDPOINT_IN if opts.has_key? :dataIn
+    return value
+  end
+end
+
+class HexProgram
+  def initialize input
+    @bytes = Hash.new(0xFF)
+    input = input.read if input.is_a? IO
+    parse input
+  end
+
+  def binary
+    bytes.pack('C*')
+  end
+  
+  def bytes
+    highest_address = @bytes.keys.max
+    
+    bytes = Array.new(highest_address + 1) { |index|
+      @bytes[index]
+    }
+  end
+
+  protected
+
+  def parse input_text
+    input_text.each_line do |line|
+      next unless line.start_with? ':'
+      line.chomp!
+      length = line[1..2].to_i(16) # usually 16 or 32
+      address = line[3..6].to_i(16) # 16-bit start address
+      record_type = line[7..8].to_i(16)
+      data = line[9... 9 + (length * 2)]
+      checksum = line[9 + (length * 2).. 10 + (length * 2)].to_i(16)
+      checksum_section = line[1...9 + (length * 2)]
+
+      checksum_calculated = checksum_section.chars.to_a.each_slice(2).map { |slice|
+        slice.join('').to_i(16)
+      }.reduce(0, &:+)
+
+      checksum_calculated = (((checksum_calculated % 256) ^ 0xFF) + 1) % 256
+
+      raise "Hex file checksum mismatch @ #{line} should be #{checksum_calculated.to_s(16)}" unless checksum == checksum_calculated
+
+      if record_type == 0 # data record
+        data_bytes = data.chars.each_slice(2).map { |slice| slice.join('').to_i(16) }
+        data_bytes.each_with_index do |byte, index|
+          @bytes[address + index] = byte
+        end
+      end
+    end
+  end
+end

data/lib/littlewire/gadgets/nunchuck.rb

@@ -0,0 +1,102 @@
+class LittleWire
+  # get Wii Nunchuck interface
+  def nunchuck
+    @nunchuck ||= LittleWire::Nunchuck.new self
+  end
+end
+
+class LittleWire::Nunchuck
+  BusAddress = 82 # Address of Nunchuck on i2c bus
+  
+  def initialize wire, interval = 0
+    @wire = wire
+    
+    raise "Nunchuck requires LittleWire firmware 1.3 or newer" unless wire.version_hex >= 0x13
+    
+    # config i2c to reliably talk with nunchuck devices
+    i2c.delay = interval # The fastest option of 0 seems to work. Neat!
+    
+    # initialize the nunchuck
+    set_register 0xf0, 0x55
+    set_register 0xfb, 0x00
+    sample # do a sample, to get the ball rolling
+  end
+  
+  def sample
+    # tell device to gather new sensor data
+    i2c.transmit BusAddress, [0]
+    # load sample in to PC
+    data = i2c.request(BusAddress, 6)
+    
+    LittleWire::Nunchuck::NunchuckFrame.new(data)
+  end
+  
+  private
+  def i2c
+    @i2c ||= @wire.i2c
+  end
+  
+  def set_register register, value
+    i2c.transmit BusAddress, [register, value]
+    sleep(0.01)
+  end
+end
+
+class LittleWire::Nunchuck::NunchuckFrame
+  def initialize data
+    @data = data
+    @joystick = Vector3D.new((data[0] / 127.5) - 1.0, (data[1] / 127.5) - 1.0)
+    @buttons = Buttons.new(((data[5] >> 1) & 1) == 0, (data[5] & 1) == 0)
+    
+    #calculate accelerometer values
+    @accelerometer = Vector3D.new(data[2] << 2, data[3] << 2, data[4] << 2)
+    @accelerometer.x |= (data[5] >> 2) & 0b11
+    @accelerometer.y |= (data[5] >> 4) & 0b11
+    @accelerometer.z |= (data[5] >> 6) & 0b11
+    
+    @accelerometer.x = (@accelerometer.x / 511.5) - 1.0
+    @accelerometer.y = (@accelerometer.y / 511.5) - 1.0
+    @accelerometer.z = (@accelerometer.z / 511.5) - 1.0
+  end
+  
+  attr_reader :joystick, :accelerometer, :buttons
+  
+  def inspect
+    "<Nunchuck:#{buttons.inspect}:#{accelerometer.inspect}:#{joystick.inspect}"
+  end
+  
+  class Vector3D
+    def initialize x=nil, y=nil, z=nil
+      @x,@y,@z = x,y,z
+    end
+    
+    attr_accessor :x,:y,:z
+    def to_a; [@x,@y,@z].compact; end
+    def to_h; {x: @x, y: @y, z: @z}; end
+    def to_hash; to_h; end
+    def inspect
+      precision = 2
+      pretty = lambda { |n| (n >= 0 ? '+' : '-') + n.abs.round(precision).to_s.ljust(precision + 2, '0') }
+      numbers = to_a.map { |n| pretty[n] }
+      "<Coords:" + numbers.join(',') + ">"
+    end
+  end
+  
+  class Buttons
+    def initialize c,z
+      @c,@z = c,z
+    end
+    attr_accessor :c, :z
+    
+    # is button down?
+    def down? button
+      instance_variable_get("@#{button.to_s.downcase}")
+    end
+    
+    def up? button
+      not down? button
+    end
+    
+    def inspect; "<Buttons:#{'C' if @c}#{'Z' if @z}>"; end
+  end
+end

data/lib/littlewire/i2c.rb

@@ -0,0 +1,92 @@
+class LittleWire::I2C
+  def initialize wire
+    @wire = wire
+    raise "i2c support requires littlewire firmware 1.2 or newer. Please update to firmware #{LittleWire::SupportedVersions.first} with the `littlewire.rb install #{LittleWire::SupportedVersions.first}` command!" if wire.version_hex < 0x12
+    warn "i2c delay support is buggy in firmware 1.2. Please update firmware to at least 1.3" if wire.version_hex == 0x12
+    @wire.control_transfer(function: :i2c_init, dataIn:8)
+  end
+  
+  # start an i2c message
+  #
+  # Arguments:
+  #   address: (Integer) 7 bit numeric address
+  #   direction: (Symbol) :in or :out
+  #
+  # Returns: true if device is active on i2c bus, false if it is unresponsive
+  def start address_7bit, direction
+    raise "Address is too high" if address_7bit > 127
+    raise "Address is too low" if address_7bit < 0
+    
+    direction = :write if direction == :out || direction == :output || direction == :send
+    config = (address_7bit.to_i << 1) | ((direction == :write) ? 0 : 1)
+    
+    @wire.control_transfer(function: :i2c_begin, wValue: config, dataIn: 8)
+    @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, stop_at_end = true
+    @wire.control_transfer(function: :i2c_read, dataIn: 8,
+                           wValue: ((length.to_i & 0xFF) << 8) + (stop_at_end ? 1 : 0),
+                           wIndex: stop_at_end ? 1 : 0)
+    @wire.control_transfer(function: :read_buffer, dataIn: 8).bytes.first(length)
+  end
+  
+  # write data to i2c device, optionally sending a stop when finished
+  def write send_buffer, stop_at_end = true
+    #send_buffer = send_buffer.pack('C*') if send_buffer.is_a? Array
+    send_buffer = send_buffer.bytes if send_buffer.is_a? String
+    
+    #byte_sets = send_buffer.each_slice(4).to_a
+    #byte_sets.each_with_index.map do |slice, index|
+    #  do_stop = stop_at_end && index >= byte_sets.length - 1 
+    slice = send_buffer
+    do_stop = stop_at_end
+      @wire.control_transfer(
+        bRequest: 0xE0 + slice.length + ((do_stop ? 1 : 0) << 3),
+        wValue: ((slice[1] || 0) << 8) + (slice[0] || 0),
+        wIndex: ((slice[3] || 0) << 8) + (slice[2] || 0),
+        dataIn: 8
+      )
+    #end
+  end
+  
+  # simplified syntax to send a message to an address
+  def transmit address, *args
+    raise "I2C Device #{address} Unresponsive" unless start(address, :write)
+    write(*args)
+  end
+  
+  # simplified syntax to read value of a register
+  def request address, *args
+    raise "I2C Device #{address} Unresponsive" unless start(address, :read)
+    read *args
+  end
+  
+  # set the update delay of LittleWire's i2c module in microseconds
+  def delay= update_delay
+    @wire.control_transfer(function: :i2c_update_delay, wValue: update_delay.to_i)
+  end
+  
+  # Search all 128 possible i2c device addresses, starting a message to each and
+  # testing if devices respond at each location.
+  #
+  # Returns: Array of Integer addresses
+  def search
+    128.times.select do |address|
+      address_responds? address
+    end
+  end
+  
+  # Test if an i2c address responds to requests - e.g. is it plugged in to the network?
+  #
+  # Arguments:
+  #   - address - an integer between 0 and 127 inclusive
+  # Returns: true or false
+  def address_responds? address
+    raise "Address must be an Integer" unless address.is_a? Integer
+    raise "Address too high. Max is 127" if address > 127
+    raise "Address too low. Needs to be at least 0" if address < 0
+    start(address, :write)
+  end
+end

data/lib/littlewire/version.rb

@@ -0,0 +1,8 @@
+class LittleWire
+  Version = '0.9.8'
+  
+  # correct interface, to enable dynamic stuff later if need be:
+  def self.version
+    LittleWire::Version
+  end
+end