littlewire 0.9 → 0.9.2

data/examples/led pixel.rb

@@ -0,0 +1,55 @@
+# Connects to an LPD6803 LED Pixel of the type sold by ladyada, bliptronics, and alibaba
+# and sends rgb info to the pixel. While these lights have worse colour reproduction than
+# the PWM in Little Wire, they're chainable so you can run hundreds off one Little Wire!
+#
+# This sort: http://bliptronics.com/item.aspx?ItemID=113
+#
+# Note if you're running more than five or so from a littlewire you should power them
+# with an external power supply instead of Little Wire's VCC pin
+require '../lib/littlewire'
+
+wire = LittleWire.connect
+spi = wire.spi
+
+wire.pin_mode :pin1 => :output, :pin3 => :output
+
+def lpd6803_data red, green, blue
+  # TODO: could add some dithering here
+  bits = [green, blue, red].map { |v| (v * 31).round.to_s(2).rjust(5, '0') }
+  "1#{bits.join ''}".to_i(2) 
+end
+
+$lights = [[1.0, 0.0, 1.0]] # just one light, with red, green, blue set to bright violet
+def update_lights
+  new_sequence = $lights.map { |pix| lpd6803_data(*pix) }
+  new_sequence.unshift 0, 0 # add start frame
+  $data_sequence = new_sequence
+end
+
+update_lights
+
+spi.delay = 10
+
+$x = 0.0
+
+require 'benchmark'
+Benchmark.benchmark do
+for i in 1..1000000
+  wire.digital_write pin1: true
+end
+end
+# loop do
+#   $data_sequence.each_slice(2) do |cells|
+#     spi.send cells.pack('S>*')
+#   end
+#   
+#   $lights = [[0.0, $x % 1.0, 0.0]]
+#   $x += 1.0/32.0
+#   update_lights
+#   
+#   # and now we use software pwm to run the light's clock for a little while
+#   wire.software_pwm_write(pin2: 127)
+#   sleep (1.0/32.0)
+#   wire.software_pwm_enabled = false
+# end
+

data/examples/ws2811 colors.rb

@@ -0,0 +1,20 @@
+require '../lib/littlewire.rb'
+wire = LittleWire.connect
+pin = :pin1
+speed = 1
+num_leds = 64
+
+loop do
+  puts "red"
+  wire.ws2811.colors = ['red'] * num_leds
+  wire.ws2811.output pin
+  sleep speed
+  puts "green"
+  wire.ws2811.colors = ['green'] * num_leds
+  wire.ws2811.output pin
+  sleep speed
+  puts "blue"
+  wire.ws2811.colors = ['blue'] * num_leds
+  wire.ws2811.output pin
+  sleep speed
+end

data/examples/ws2811 scan.rb

@@ -0,0 +1,25 @@
+require '../lib/littlewire.rb'
+wire = LittleWire.connect
+num_pixels = ARGV.first.to_i
+
+lit = 0
+loop do
+  
+  text_output = ['-'] * num_pixels
+  text_output[lit] = '*'
+  puts text_output.join
+  
+  wire.ws2811.colors = num_pixels.times.map do |idx|
+    if idx == lit
+      'white'.to_color
+    else
+      'black'.to_color
+    end
+  end
+  wire.ws2811.output :pin1
+  
+  lit += 1
+  lit %= num_pixels
+  
+  sleep 0.01
+end

data/examples/ws2811.rb

@@ -0,0 +1,39 @@
+# Send up to 64 colours to a string of WS2812 LEDs or 800khz (version 2) Adafruit Flora NeoPixels
+# Any 800khz mode ws2811 pixels will work
+require '../lib/littlewire.rb'
+wire = LittleWire.connect
+
+puts DATA.read # print out the little ascii art thing at the end of this file
+puts "Which pin to use for data output?"
+print "Enter pin number: "
+output_pin = gets.gsub(/[^0-9]/, '').to_i
+
+print "Enter 1st color: "
+wire.ws2811.colors = [gets.strip.to_color]
+wire.ws2811.output(output_pin) # output our first color
+
+titles = ['1st', '2nd', '3rd']
+
+63.times do |idx|
+  print "Enter #{titles[idx + 1] || "#{idx + 2}th"} color: "
+  gotten = gets.strip
+  break if gotten.empty?
+  # add colour to array
+  wire.ws2811.colors.push gotten.to_color
+  wire.ws2811.output(output_pin) # output the colours to the string
+end
+
+puts "All done!"
+
+__END__
+ LittleWire connector:   |   Digispark Board:
+        /-----\          |         _________
+  pin_1 | o o | vcc      |   _____|        o| ds5
+  pin_2 | o o | pin 4    |  |-----         o| (usb - not available)
+  pin_3 | o o | gnd      |  |-----         o| (usb - not available)
+        \-----/          |  |-----         o| ds2
+                            |-----         o| ds1
+                                  |_o_o_o__o| ds0
+                                    5 g v
+                                    v n c
+                                      d c

data/lib/digital.rb

@@ -58,7 +58,7 @@ module LittleWire::Digital
   # `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
+  # digital_read works best when the pin is in :input mode. See also #pin_mode
   def digital_read *args
     raise "Incorrect Arguments" if args.length < 1
     pins = args.flatten

data/lib/littlewire.rb

@@ -11,6 +11,7 @@ require_relative 'servo'
 require_relative 'spi'
 require_relative 'i2c'
 require_relative 'one-wire'
+require_relative 'ws2811'
 
 # LittleWire class represents LittleWire's connected to your computer via USB
 # 
@@ -25,10 +26,10 @@ class LittleWire
   
   # 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 }
+    pin1: 1, d1: 1, miso:  1, pwm_b: 1, pwm_2: 1, ds1: 1,
+    pin2: 2, d2: 2, sck:   2, ds2: 2,
+    pin3: 5, d3: 5, reset: 5, ds5: 5,
+    pin4: 0, d4: 0, mosi:  0, pwm_a: 0, pwm_1: 0, ds0: 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,
@@ -37,9 +38,9 @@ class LittleWire
     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 }
+    softpwm_1: 0, softpwm_a: 0, pin4: 0, d4: 0, mosi: 0, pwm_a: 0, pwm_1: 0,
+    softpwm_2: 1, softpwm_b: 1, pin1: 1, d1: 1, miso: 1, pwm_b: 1, pwm_2: 1,
+    softpwm_3: 2, softpwm_c: 2, pin2: 2, d2: 2, sck: 2 }
   GenericPinMap = { # generic pinmap used by [] and []= methods to refer to anything
     d1: [:digital, :pin1],
     d2: [:digital, :pin2],
@@ -65,7 +66,7 @@ class LittleWire
     softpwm_c: [:software_pwm, :softpwm_c],
   }
   
-  SupportedVersions = ['1.1', '1.0'] # in order of newness. # TODO: Add version 1.0?
+  SupportedVersions = ['1.2', '1.1', '1.0'] # in order of newness. # TODO: Add version 1.0?
   
   
   # An array of all unclaimed littlewires connected to computer via USB
@@ -120,11 +121,11 @@ class LittleWire
   
   # 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
+  #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
@@ -151,12 +152,23 @@ class LittleWire
     @i2c ||= I2C.new(self)
   end
   
-  # get the 1wire interface (requires firmware 1.1 or newer
+  # 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
   
+  # get the ws2811 led strip interface (requires firmware 1.2 or newer)
+  # optionally call with pin number to preset it
+  def ws2811 pin = false
+    raise "You need to update your LittleWire firmware to version 1.2 to use One Wire" unless version_hex >= 0x12
+    @ws2811 ||= Array.new
+    @ws2811[pin || 0] ||= WS2811.new(self, pin)
+    return @ws2811[pin || 0]
+  end
+  
+  alias_method :ws2812, :ws2811
+  
   
   
   # translate calls with arduino-style lowerCamelCase method names in to ruby-style underscored_method_names
@@ -259,7 +271,9 @@ class LittleWire
     :onewire_read_bit,    # 50
     :onewire_write_bit,   # 51
     :pic_24f_programming, # 52 - experimental
-    :pic_24f_sendsix      # 53 - experimental
+    :pic_24f_sendsix,     # 53 - experimental
+    :ws2812_write,        # 54 - experimental
+    :ws2812_preload       # 55 - experimental
     # special cases
     # pic 24f send bytes - request = 0xD*
     # i2c send multiple messages - request = 0xE*     ### experimental ###
@@ -278,10 +292,9 @@ class LittleWire
   
   # 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
+    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
   

data/lib/software-pwm.rb

@@ -34,10 +34,17 @@ module LittleWire::SoftwarePWM
   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
+  def software_pwm_write *args
+    if args.first.is_a? Hash
+      state = self.software_pwm
+      args.first.each do |channel, value|
+        state[get_pin(LittleWire::SoftwarePWMPinMap, channel)] = value
+      end
+      self.software_pwm = state
+    else
+      raise "Invalid Arguments" unless args.length == 2
+      self.software_pwm_write(args.first => args.last)
+    end
   end
   
   def is_software_pwm_available?

data/lib/spi.rb

@@ -6,12 +6,14 @@ class LittleWire::SPI
   end
   
   # send and receive a message of up to four bytes
-  def send send, receive, auto_chipselect = false
+  def send send, auto_chipselect = false
     mode = auto_chipselect ? 1 : 0
+    bytes = send.bytes.to_a
     @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]
+      bRequest: 0xF0 + send.length + (mode << 3),
+      wValue: bytes[1].to_i << 8 | bytes[0].to_i,
+      wIndex: bytes[3].to_i << 8 | bytes[2].to_i,
+      dataIn: bytes.length
     )
   end
   

data/lib/ws2811.rb

@@ -0,0 +1,52 @@
+require 'colorist'
+
+# Output colours to ws2812 strips and other 800khz ws2811 led devices
+# To use, simply set colours in the 'colors' array property as css color strings
+# or Colorist::Color objects, then call #output(pin) to send it on it's way
+# 
+# Note that this requires firmware v1.2 which is not yet released and there is a
+# maximum of 64 lights in the firmware at the time of writing
+# 
+# Also note that you can connect 64 leds to each of the digital pins on the LittleWire
+# or Digispark device, and this enables you a total of 64 * 4 = 256 lights! Neato!
+class LittleWire::WS2811
+  attr_accessor :colors
+  attr_accessor :pin
+  
+  
+  def initialize wire, default_pin = false # :nodoc:
+    @wire = wire
+    @pin = default_pin
+    @colors = []
+  end
+  
+  # send colours to strip, optionally specifying a pin if not specified via
+  # littlewire.ws2811(pin).output
+  def output pin = nil
+    colors_buffer = @colors.map { |i| i.is_a?(Colorist::Color) ? i : i.to_color }
+    output_pin = @wire.get_pin(LittleWire::DigitalPinMap, pin || @pin)
+    raise "Must specify output pin for ws2811 strip" unless output_pin.is_a? Integer
+    
+    until colors_buffer.empty?
+      
+      if colors_buffer.length > 1
+        color = colors_buffer.shift
+        
+        @wire.control_transfer(
+          function: :ws2812_preload,
+          wIndex: color.b << 8 | color.r,
+          wValue: color.g << 8
+        )
+      elsif colors_buffer.length == 1
+        color = colors_buffer.shift
+        
+        @wire.control_transfer(
+          function: :ws2812_write,
+          wIndex: color.b << 8 | color.r,
+          wValue: color.g << 8 | output_pin
+        )
+      end
+    end
+  end
+end
+

data/readme.md

@@ -53,8 +53,8 @@ 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)
+test ideas before changing them to C and uploading them to cheaper avr tiny chips
+(also using the Little Wire to program them)
 
 
 ### a warning ###

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: littlewire
 version: !ruby/object:Gem::Version
-  version: '0.9'
+  version: 0.9.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-09-20 00:00:00.000000000 Z
+date: 2013-05-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: libusb
@@ -27,6 +27,22 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: colorist
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.0.2
 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,
@@ -46,10 +62,15 @@ files:
 - lib/servo.rb
 - lib/software-pwm.rb
 - lib/spi.rb
+- lib/ws2811.rb
 - readme.md
 - license.txt
 - examples/blinky.rb
 - examples/fadey.rb
+- examples/led pixel.rb
+- examples/ws2811 colors.rb
+- examples/ws2811 scan.rb
+- examples/ws2811.rb
 homepage: http://creativepony.com/littlewire/
 licenses: []
 post_install_message: 
@@ -72,7 +93,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.21
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: A tiny library for littlewire.cc usb devices