littlewire 0.9.7 → 0.9.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 672e15656164047ad4895db0099cea33b13bb861
-  data.tar.gz: 79ecc40349391da72aa766b11c7f2ec667a565ae
+  metadata.gz: 3ce81eaa4836881938aeca5d6d4300f49f90fcef
+  data.tar.gz: f8b8ba8827f9b23abfe77339b4684bc250bb04ef
 SHA512:
-  metadata.gz: 7959de400ac104e7671353af22aa9207d1d74a71ecee220ec2629bc87b08956a745eb5d8d29a01e1501fb906fb69440e8e53726854bf5ff156d28355973bc70b
-  data.tar.gz: f1e7674e363807d7d8e1af74d0504a9f0d5740c31ff04d5be17ec73814a5e2a0d65b4a9cb5886ecf279f1fda5a29eba74057300965086391d9897ecf1dac31bf
+  metadata.gz: 2ec2ac2d655f97325571c7ff1f4605a5c3ba0e1f451c4e92ae408f8863b55f26d919cb71d4d2181081caa06f3ec6ced62cefc844ff9317031cc2da76c5733f6b
+  data.tar.gz: 1290c8bd90d384ebcf25d3f7dd535d04609e70826566bc5327b2f4ce04a18a2d938170a97cb5f2839852f8a432d6de687f3a38b33709aaac942186035ad372a0

data/bin/littlewire.rb

@@ -0,0 +1,79 @@
+#!/usr/bin/env ruby
+__dir__ ||= File.dirname(__FILE__)
+#$:.unshift File.join(__dir__, '..', 'lib')
+require 'thor'
+require 'pp'
+require 'littlewire'
+require 'littlewire/gadgets/micronucleus'
+
+class LittleWireUtility < Thor
+  desc "install [version]", "Install a specific firmware on to the littlewire device"
+  def install version = 'latest'
+    path = File.join(__dir__, "..", "firmware", "#{version}.hex")
+    raise "Unknown Version" unless File.file? path
+    
+    data = HexProgram.new(open path).binary
+    
+    retried = false
+    begin
+      puts "Will upload to a littlewire which has been updated with the micronucleus bootloader, or to a digispark."
+      puts "Plug in micronucleus device now: (waiting)"
+      sleep 0.25 while Micronucleus.all.length == 0
+    
+      nucleus = Micronucleus.all.first
+      puts "Attached to device: #{nucleus.inspect}"
+    
+      sleep(0.25) # some time to think?
+      puts "Writing program in to device's memory"
+      nucleus.program = data
+
+      puts "Great! Starting new littlewire firmware..."
+      nucleus.finished # let thinklet know it can go do other things now if it likes
+    rescue LIBUSB::ERROR_IO => err
+      unless retried
+        retried = true
+        retry
+      end
+      raise err
+    end
+    
+    puts "All done!"
+    puts "If littlewire doesn't automatically appear in a few seconds, unplug and replug device from USB port"
+  end
+  
+  desc "firmwares", "List all versions which can be installed via install command"
+  def firmwares
+    puts "Available LittleWire Firmware:"
+    Dir[File.join(__dir__, "..", "firmware", "*.hex")].each do |filename|
+      puts File.basename(filename, '.hex')
+    end
+  end
+  
+  desc "version", "Which version of the ruby library is this?"
+  def version
+    puts "Library Version: #{LittleWire.version}"
+    
+    wire = LittleWire.connect
+    puts "Device Firmware: #{wire.version}" if wire
+    
+    latest_path = File.join(__dir__, "..", "firmware", "#{LittleWire::SupportedVersions.first}.hex")
+    if LittleWire::SupportedVersions.index(wire.version) != 0 and File.exists? latest_path
+      puts "An updated firmware is available, version #{LittleWire::SupportedVersions.first}"
+      puts "To update, run:"
+      puts "  littlewire.rb install #{LittleWire::SupportedVersions.first}"
+      puts ""
+      puts "If you bought your LittleWire as a kit from Seeed Studios, you may need to first"
+      puts "install the Micronucleus bootloader as described on the littlewire.cc website."
+      puts ""
+    end
+  end
+  
+  desc "racer", "Attach a Wii Nunchuck and play a game"
+  def racer
+    ruby_vm = File.join(RbConfig::CONFIG['bindir'], RbConfig::CONFIG['ruby_install_name'])
+    system(ruby_vm, File.join(__dir__, '..', 'examples', 'i2c', 'nunchuck.rb'))
+  end
+end
+
+LittleWireUtility.start(ARGV)
+

data/examples/i2c/microchip-eeprom.rb

@@ -0,0 +1,33 @@
+require 'littlewire'
+
+# Make a class which represents a digispark with the digistump eeprom shield attached
+# with LittleWire installed
+class MicrochipEEPROM
+  def initialize wire = LittleWire.connect, address = 0x50
+    raise "EEPROM device not responding" unless wire.i2c.address_responds? address
+    
+    @wire = wire
+    @device = address
+    
+    @wire.i2c.delay = 10
+  end
+  
+  def read address
+    @wire.i2c.transmit @device, [(address >> 8) & 0xFF, address & 0xFF]
+    @wire.i2c.request(@device, 1)
+  end
+  
+  def write address, data
+    @wire.i2c.transmit @device, [address >> 8, address & 0xFF, data]
+    sleep 0.01 # time to write data
+  end
+end
+
+eep = MicrochipEEPROM.new
+
+number = rand(127)
+puts "Random number is #{number}"
+puts "Writing to eeprom at address 0"
+eep.write 0, number
+puts "Reading back..."
+puts eep.read(0)

data/examples/i2c/nunchuck.rb

@@ -0,0 +1,80 @@
+# This little example shows the nunchuck gadget extension
+# The Nunchuck gadget lets you easily connect with Nintendo Wii-compatible
+# 'Nunchuck' devices using the I2C feature of the LittleWire device.
+require 'littlewire'
+require 'littlewire/gadgets/nunchuck'
+
+wire = LittleWire.connect
+wire.pin_mode :ds5, :output
+wire.digital_write :ds5, :low
+
+car = 0.0
+wall = 0.0
+wall_width = 16
+constraint = 20.0
+
+puts DATA.read
+puts ''
+puts "Point your nunchuck at the screen, and press C button to start your engines!"
+sleep 0.1 until wire.nunchuck.sample.buttons.c
+
+seconds = 0.0
+seconds_since_gearshift = 0.0
+last_full_second = 0
+step = 0.1
+
+GearshiftInterval = 10.0
+
+loop do
+  controller = wire.nunchuck.sample
+  car += controller.accelerometer.x * 2.0
+  
+  wall += rand(3) - 1
+  wall = -20.0 if wall < -constraint
+  wall = +20.0 if wall > +constraint
+  
+  real_wall = wall + constraint * 2 + 1
+  real_car = car + constraint * 2 + 1
+  
+  string = " " * 80
+  string[real_wall - wall_width / 2] = '|'
+  string[real_wall + wall_width / 2] = '|'
+  string[real_car] = '5'
+  
+  if seconds > last_full_second + 5
+    string[0...10] = seconds.round.to_s.ljust(10, ' ')
+    last_full_second = seconds.round
+  end
+  puts string
+  
+  raise "Crashed your car!" if real_car < real_wall - (wall_width / 2)
+  raise "Crashed your car!" if real_car > real_wall + (wall_width / 2)
+  
+  sleep step
+  seconds += step
+  seconds_since_gearshift += step
+  if seconds_since_gearshift > GearshiftInterval
+    step *= 0.8
+    seconds_since_gearshift = 0.0
+  end
+end
+
+__END__
+                    ______   __  __    ____     ____     ____                 
+                   /_  __/  / / / /   / __ \   / __ )   / __ \                
+                    / /    / / / /   / /_/ /  / __  |  / / / /                
+                   / /    / /_/ /   / _, _/  / /_/ /  / /_/ /                 
+                  /_/     \____/   /_/ |_|  /_____/   \____/                  
+                    ____     ___      ______   ______   ____               
+                   / __ \   /   |    / ____/  / ____/  / __ \              
+                  / /_/ /  / /| |   / /      / __/    / /_/ /              
+                 / _, _/  / ___ |  / /___   / /___   / _, _/               
+                /_/ |_|  /_/  |_|  \____/  /_____/  /_/ |_|                
+          ______   _  __  ______   ____     ______   __  ___   ______
+         / ____/  | |/ / /_  __/  / __ \   / ____/  /  |/  /  / ____/
+        / __/     |   /   / /    / /_/ /  / __/    / /|_/ /  / __/   
+       / /___    /   |   / /    / _, _/  / /___   / /  / /  / /___   
+      /_____/   /_/|_|  /_/    /_/ |_|  /_____/  /_/  /_/  /_____/        
+
+             Motion Nunchuck Ninja Edition 2.1 - Insert Coin
+   Published by Mechanum Industries for PC-DOS, Amega, VIC 20, and iPhone 5c

data/examples/i2c/search.rb

@@ -0,0 +1,5 @@
+# This little example searches the i2c bus and lists all the responsive addresses
+require 'littlewire'
+
+wire = LittleWire.connect
+puts "Active Addresses: #{wire.i2c.search.inspect}"

data/examples/ws2811/all.rb

@@ -0,0 +1,44 @@
+# 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 'littlewire'
+wire = LittleWire.connect
+
+if wire == nil
+  puts "Couldn't find an attached LittleWire device"
+  exit
+end
+
+if ARGV.length != 2
+  puts DATA.read # print out the little ascii art help
+  exit
+end
+
+pin = ARGV[0].gsub(/[^0-9a-zA-Z]/, '').downcase
+color = ARGV[1]
+
+puts "Setting 64 pixels connected to #{pin} to be #{color}"
+wire.ws2811(pin).send([color] * 64)
+
+puts "All done!"
+
+__END__
+
+all.rb sets 64 pixels connected to a littlewire (or digispark) pin to
+a specific colour. You can specify this colour by CSS name 'red'
+or by web-style hex code '#ff0000', or with CSS-style RGB constructs
+'(rgb(255, 0, 0)'. Run all.rb with two arguments - the output pin name
+followed by the colour.
+
+ LittleWire connector:   |   Digispark Board:
+       /-----\         |         _________
+  pin1 | o o | vcc     |   _____|        o| ds5
+  pin2 | o o | pin4    |  |-----         o| (usb - not available)
+  pin3 | o o | gnd     |  |-----         o| (usb - not available)
+       \-----/         |  |-----         o| ds2
+                          |-----         o| ds1
+                                |_o_o_o__o| ds0
+                                  5 g v
+                                  v n c
+                                    d c
+
+Example: ruby all.rb pin4 aqua

data/examples/ws2811/colors.rb

@@ -0,0 +1,28 @@
+require 'littlewire'
+wire = LittleWire.connect
+pin = :pin4
+speed = 1
+num_leds = 64
+
+hue = 0.0
+
+loop do
+  puts "red"
+  wire.ws2811(pin).send(['red'] * num_leds)
+  sleep speed
+  
+  puts "green"
+  wire.ws2811(pin).send(['green'] * num_leds)
+  sleep speed
+  
+  puts "blue"
+  wire.ws2811(pin).send(['blue'] * num_leds)
+  sleep speed
+  # red = 1.0 + (Math.sin(hue) * 127)
+  # green = 1.0 + (Math.sin(hue + ((Math::PI*2.0) / 3)) * 127)
+  # blue = 1.0 + (Math.sin(hue - ((Math::PI*2.0) / 3)) * 127)
+  # 
+  # wire.ws2811(pin).send([Colorist::Color.from_rgb(red, green, blue)] * num_leds)
+  # 
+  # hue += 0.5
+end

data/examples/ws2811/manual.rb

@@ -0,0 +1,43 @@
+# 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 'littlewire'
+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-9a-zA-Z]/, '').downcase
+
+puts "Blacking out strip"
+wire.ws2811(output_pin).black!
+
+colors = []
+
+# 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] || "#{idx + 1}th"} color: "
+  gotten = gets.strip
+  break if gotten.empty?
+  colors << gotten.to_color
+  wire.ws2811(output_pin).send colors
+end
+
+puts "All done!"
+
+__END__
+ LittleWire connector:   |   Digispark Board:
+       /-----\         |         _________
+  pin1 | o o | vcc     |   _____|        o| ds5
+  pin2 | o o | pin4    |  |-----         o| (usb - not available)
+  pin3 | 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/examples/ws2811/scan.rb

@@ -0,0 +1,26 @@
+require 'littlewire'
+wire = LittleWire.connect
+num_pixels = ARGV.first.to_i
+pin = :pin4
+
+lit = 0
+loop do
+  
+  text_output = ['-'] * num_pixels
+  text_output[lit] = '*'
+  puts text_output.join
+  
+  wire.ws2811(pin).send num_pixels.times.map { |idx|
+    if idx == lit
+      'white'.to_color
+    else
+      'black'.to_color
+    end
+  }
+  
+  lit += 1
+  lit %= num_pixels
+  
+  sleep 0.005
+end
+

data/examples/ws2811/spin.rb

@@ -0,0 +1,17 @@
+require 'littlewire'
+include Colorist
+wire = LittleWire.connect
+num_pixels = ARGV.first.to_i
+
+loop do
+  position = (Time.now.to_f / 60) % 1
+  wire.ws2811.colors = num_pixels.times.map do |idx|
+    brightness = Math.sin((position - (idx.to_f / num_pixels)) * Math::PI * 2) * 255
+    Color.from_rgb(0, brightness.to_i, 0)
+  end
+  
+  wire.ws2811.output :pin4
+  
+  sleep 1.0 / 60.0
+end
+

data/examples/ws2811/strobe.rb

@@ -0,0 +1,93 @@
+require 'littlewire'
+wire = LittleWire.connect
+pin = :pin4
+num_leds = 19
+MaxBPM = 500
+AveragedTaps = 8
+
+puts "Outputtting data to LittleWire pin named '#{pin}'"
+
+strobe_duration = 0.01
+bpm = 30
+last_tap = Time.now.to_f
+tap_bpms = []
+last_strobe = Time.now.to_f
+reset = false
+
+wire.ws2811(pin).black!
+
+puts "Enter BPM and press enter to set it"
+puts "Or, tap enter key (leave blank) to the beat to detect BPM"
+puts "Or, enter z to halve current bpm and x to double it, followed by enter"
+
+Thread.abort_on_exception = true
+interface = Thread.start do
+  loop do
+    print "Enter BPM: "
+    str = $stdin.gets.strip
+    time = Time.now.to_f
+    new_bpm = bpm
+    
+    if str == 'z'
+      new_bpm = bpm / 2.0
+      tap_bpms.map! { |x| x / 2.0 }
+      
+    elsif str == 'x'
+      new_bpm = bpm * 2.0
+      tap_bpms.map! { |x| x * 2 }
+      
+    elsif str.empty?
+      # calculate bpm from last tap and this one
+      tap_bpm = 60.0 / (time - last_tap)
+      
+      # add tap to list and compute average
+      tap_bpms.push tap_bpm
+      tap_bpms = tap_bpms.last(AveragedTaps)
+      
+      # compute average
+      avg = tap_bpms.reduce(:+) / tap_bpms.length
+      nearest_subset = tap_bpms.sort { |a,b| (a - avg).abs <=> (b - avg).abs }.first(tap_bpms.length / 2)
+      
+      new_bpm = nearest_subset.reduce(:+) / nearest_subset.length if nearest_subset.length >= 2
+      
+      # because strobes are mainly used with electro music, and electro music is
+      # usually whole number BPMs, round it to the nearest full bpm
+      new_bpm = new_bpm.round
+      
+      # set last strobe and last tap to now, so a new strobe begins immediately
+      last_strobe = last_tap = time
+      reset = true # ask main thread to skip timers and start a new strobe now
+      
+      puts "TAP!"
+    else # numbers were typed in presumably!
+      new_bpm = (str.to_f rescue bpm)
+      tap_bpms.clear # reset tap bpm system
+    end
+    
+    new_bpm = MaxBPM if new_bpm > MaxBPM
+    new_bpm = 30.0 if new_bpm < 30.0
+    bpm = new_bpm
+    puts "Set to #{bpm}"
+  end
+end
+
+loop do
+  last_strobe = Time.now.to_f
+  wire.ws2811(pin).set ['white'] * num_leds
+  
+  while Time.now.to_f - last_strobe <= strobe_duration and !reset
+    Thread.pass
+  end
+  
+  wire.ws2811(pin).set ['black'] * num_leds
+  blackout_duration = (60.0 / bpm) - strobe_duration
+  
+  while Time.now.to_f - last_strobe <= 60.0 / bpm and !reset
+    Thread.pass
+  end
+  
+  last_strobe += 60.0 / bpm
+  
+  #sleep((60.0 / bpm) - strobe_duration) if blackout_duration > 0
+  reset = false
+end