blinkytape-orb 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    M2U5ZTcxOWE3OGMxYTllMWY1YTMzNTY4MGZjMzJkYzRmNDdiNjk3Yg==
+  data.tar.gz: !binary |-
+    MTA2NDAwNjY4YTZjNWM4MjZlNDBkMTcxNjU3NzkxOGEyYzliNDY3Mg==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    ZWUzZTk1YzEwYWMxMzJiMGJiZTU0NjdjMjFiMjRjOTdmOGU2Zjk3NDkwM2U2
+    MTExY2U4ODdlZDFhYjE4NTNlYTcwMTQ5NWMxOTRiZjY0OWVlMDFhMGRiNjNj
+    NjYzYTY4YTk4ZmQ4ZDc1OTA2N2IxMjZlOTlmMTRiYzg0ZTU4Y2E=
+  data.tar.gz: !binary |-
+    ZjdjYTNmZGZmYmI3MGE3N2ZmYWUwMDViNWUxMjAzMzlmZmIwYWIyNzFkNDky
+    ZjM1NDM0N2I2ODllNDhlMmM3YTdhNWExNTMwMzgxZjY3NDlhYWMyYzAxMjA4
+    YTdjZTRlNzUzZjljM2MxZjAzNmZhMjQwNjEzOGJkZTlmOTUzMWQ=

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+Gemfile.lock
+.rvmrc
+.DS_Store
+/coverage

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+gemspec
+
+group :test do
+  gem 'rspec', '~> 3.4.0'
+  gem 'rspec-instafail', '~> 0.4'
+  gem 'simplecov', :require => false
+end

data/README.md

@@ -0,0 +1,45 @@
+BlinkyTape Orb
+==============
+
+Ruby code to interface with a [BlinkyTape controller board](http://blinkinlabs.myshopify.com/collections/frontpage/products/blinkytape-control-board)
+running the custom firmware in the `arduino` directory of this repository. See
+the [Blinkinlabs arduino instructions](http://blinkinlabs.com/blinkytape/arduino/)
+for how to install the firmware. The firmware can be made to work on an Arduino
+Uno R3 with some modifications, mainly around the button handling.
+
+```ruby
+require 'blinkytape-orb'
+
+# device is automatically detected on OS X
+orb = BlinkyTapeOrb.new
+
+# a device can be passed manually
+#orb = BlinkyTapeOrb.new(:device => '/dev/ttyS0')
+
+# a logger can also be passed
+#orb = BlinkyTapeOrb.new(:logger => Logger.new(STDOUT))
+#orb.logger.level = Logger::DEBUG
+
+[
+  BlinkyTapeOrb::BRIGHTNESS_MIN,
+  BlinkyTapeOrb::BRIGHTNESS_MED,
+  BlinkyTapeOrb::BRIGHTNESS_MAX,
+].each do |brightness|
+  orb.setBrightness(brightness)
+  sleep(1)
+end
+
+sleep(3)
+
+[
+  [ BlinkyTapeOrb::COLOR_GREEN,  BlinkyTapeOrb::PULSE_NONE ],
+  [ BlinkyTapeOrb::COLOR_BLUE,   BlinkyTapeOrb::PULSE_SLOW ],
+  [ BlinkyTapeOrb::COLOR_PURPLE, BlinkyTapeOrb::PULSE_SLOW ],
+  [ BlinkyTapeOrb::COLOR_YELLOW, BlinkyTapeOrb::PULSE_MED  ],
+  [ BlinkyTapeOrb::COLOR_ORANGE, BlinkyTapeOrb::PULSE_MED  ],
+  [ BlinkyTapeOrb::COLOR_RED,    BlinkyTapeOrb::PULSE_FAST ],
+].each do |(color, animation)|
+  orb.update(color, animation)
+  sleep(10)
+end
+```

data/arduino/blinkytape_orb.ino

@@ -0,0 +1,230 @@
+#include "FastLED.h"
+
+// hardware
+#define NUM_LEDS 12
+#define LED_CORRECTION TypicalSMD5050
+
+#define DATA_PIN 13
+#define BUTTON_IN 10
+#define ANALOG_INPUT A9
+#define EXTRA_PIN_A 7
+#define EXTRA_PIN_B 11
+
+// visuals
+#define PULSE_MAX_VAL 255
+#define PULSE_MIN_VAL 160
+#define PULSE_DURATION_SLOW 3000
+#define PULSE_DURATION_MED 1500
+#define PULSE_DURATION_FAST 0
+
+#define CHANGE_MIN_VAL 64
+#define CHANGE_DURATION 800
+
+#define BRIGHTNESS_MAX 255
+#define BRIGHTNESS_MED 106
+#define BRIGHTNESS_MIN 32
+
+// state
+CRGB leds[NUM_LEDS];
+
+bool initialized;
+
+uint8_t hue;
+uint8_t val;
+bool pulse;
+long pulse_duration;
+
+bool buttonDebounced;
+uint8_t brightness;
+
+
+void fade(uint8_t new_val, long duration) {
+  if (val == new_val) {
+    // setBrightness() requires a call to delay() periodically
+    FastLED.delay(duration);
+    return;
+  }
+  
+  int incr;
+  long delay_ms;
+  long change_delay_ms;
+  if (val < new_val) {
+    incr = 1;
+    delay_ms = duration / (new_val - val);
+    if (CHANGE_DURATION / 2 < duration) {
+      change_delay_ms = (CHANGE_DURATION / 2) / (new_val - val);
+    } else {
+      change_delay_ms = delay_ms;
+    }
+  } else if (val > new_val) {
+    incr = -1;
+    delay_ms = duration / (val - new_val);
+    if (CHANGE_DURATION / 2 < duration) {
+      change_delay_ms = (CHANGE_DURATION / 2) / (val - new_val);
+    } else {
+      change_delay_ms = delay_ms;
+    }
+  }
+
+  for (uint8_t v = val; v != new_val; v += incr) {
+    for (int i = 0; i < NUM_LEDS; i++) {
+      if (initialized) {
+        leds[i] = CHSV(hue, 255, v);
+      } else {
+        leds[i] = CRGB(v, v, v);
+      }
+    }
+    FastLED.show();
+
+    // check to see if we've been given a new command, if so, hurry things along
+    if (Serial.available() > 0) {
+      FastLED.delay(change_delay_ms);
+    } else {
+      FastLED.delay(delay_ms);
+    }
+  }
+
+  val = new_val;
+}
+
+void setup() {
+  Serial.begin(57600);
+
+  FastLED.addLeds<NEOPIXEL, DATA_PIN>(leds, NUM_LEDS);
+  FastLED.setCorrection(LED_CORRECTION);
+
+  initialized = false;
+
+  val = PULSE_MAX_VAL;
+  pulse = true;
+  pulse_duration = PULSE_DURATION_MED;
+
+  brightness = BRIGHTNESS_MED;
+  FastLED.setBrightness(brightness);
+
+  for (int i = 0; i < NUM_LEDS; i++) {
+    leds[i] = CRGB(val, val, val);
+  }
+  FastLED.show();
+
+  pinMode(BUTTON_IN, INPUT_PULLUP);
+  pinMode(ANALOG_INPUT, INPUT_PULLUP);
+  pinMode(EXTRA_PIN_A, INPUT_PULLUP);
+  pinMode(EXTRA_PIN_B, INPUT_PULLUP);
+
+  // Interrupt set-up; see Atmega32u4 datasheet section 11
+  PCIFR  |= (1 << PCIF0);  // Just in case, clear interrupt flag
+  PCMSK0 |= (1 << PCINT6); // Set interrupt mask to the button pin (PCINT6)
+  PCICR  |= (1 << PCIE0);  // Enable interrupt
+}
+
+void loop() {
+  if (pulse) {
+    fade(PULSE_MIN_VAL, pulse_duration / 2);
+  }
+
+  if (Serial.available() > 0) {
+    byte c = Serial.read();
+    c -= 65; // align to ASCII "A"
+    switch (c) {
+      case 32:
+        brightness = BRIGHTNESS_MIN;
+        FastLED.setBrightness(brightness);
+        break;
+      case 33:
+        brightness = BRIGHTNESS_MED;
+        FastLED.setBrightness(brightness);
+        break;
+      case 34:
+        brightness = BRIGHTNESS_MAX;
+        FastLED.setBrightness(brightness);
+        break;
+      default:
+        if (c < 24) { // filter out garbage values
+          fade(CHANGE_MIN_VAL, CHANGE_DURATION / 2);
+    
+          switch (c & B00000011) {
+            case 0:
+              pulse = false;
+              pulse_duration = CHANGE_DURATION;
+              break;
+            case 1:
+              pulse = true;
+              pulse_duration = PULSE_DURATION_SLOW;
+              break;
+            case 2:
+              pulse = true;
+              pulse_duration = PULSE_DURATION_MED;
+              break;
+            case 3:
+              pulse = true;
+              pulse_duration = PULSE_DURATION_FAST;
+              break;
+          }
+      
+          switch ((c & B00011100) >> 2) {
+            case 0:
+              hue = HUE_RED;
+              break;
+            case 1:
+              hue = HUE_ORANGE;
+              break;
+            case 2:
+              hue = HUE_YELLOW;
+              break;
+            case 3:
+              hue = HUE_GREEN;
+              break;
+            case 4:
+              hue = HUE_BLUE;
+              break;
+            case 5:
+              hue = HUE_PURPLE;
+              break;
+          }
+    
+          initialized = true;
+    
+          fade(PULSE_MIN_VAL, CHANGE_DURATION / 2);
+        }
+        break;
+    }
+  }
+
+  fade(PULSE_MAX_VAL, pulse_duration / 2);
+}
+
+// Called when the button is both pressed and released
+ISR(PCINT0_vect){
+  if (!(PINB & (1 << PINB6))) {
+    buttonDebounced = false;
+
+    // Configure and start timer4 interrupt.
+    TCCR4B = 0x0F; // Slowest prescaler
+    TCCR4D = _BV(WGM41) | _BV(WGM40);  // Fast PWM mode
+    OCR4C = 0x10;        // some random percentage of the clock
+    TCNT4 = 0;  // Reset the counter
+    TIMSK4 = _BV(TOV4);  // turn on the interrupt
+  } else {
+    TIMSK4 = 0;  // turn off the interrupt
+  }
+}
+
+// Called every xx ms while the button is being held down
+ISR(TIMER4_OVF_vect) {
+  if (buttonDebounced == false) {
+    buttonDebounced = true;
+    switch (brightness) {
+      case BRIGHTNESS_MIN:
+        brightness = BRIGHTNESS_MED;
+        break;
+      case BRIGHTNESS_MED:
+        brightness = BRIGHTNESS_MAX;
+        break;
+      case BRIGHTNESS_MAX:
+        brightness = BRIGHTNESS_MIN;
+        break;
+    }
+    FastLED.setBrightness(brightness);
+  }
+}

data/blinkytape-orb.gemspec

@@ -0,0 +1,21 @@
+# encoding: utf-8
+$:.push File.expand_path("../lib", __FILE__)
+
+require 'blinkytape-orb/version'
+
+Gem::Specification.new do |s|
+  s.name         = "blinkytape-orb"
+  s.version      = BlinkyTapeOrb::VERSION
+  s.platform     = Gem::Platform::RUBY
+  s.authors      = ["Jon Tai"]
+  s.email        = ["jon.tai@gmail.com"]
+  s.homepage     = "https://github.com/jtai/blinkytape-orb"
+  s.summary      = "Ruby code to interface with BlinkyTape controller board running custom firmware"
+  s.description  = "Other hardware (e.g., arduino) may be supported with minor firmware modifications"
+
+  s.files        = `git ls-files`.split("\n")
+  s.test_files   = `git ls-files -- spec/*`.split("\n")
+  s.require_path = 'lib'
+
+  s.add_runtime_dependency 'serialport', '>= 1.3.1'
+end

data/lib/blinkytape-orb.rb

@@ -0,0 +1,92 @@
+require 'blinkytape-orb/version'
+require 'logger'
+require 'serialport'
+
+class BlinkyTapeOrb
+
+  SERIAL_PORT_BAUD_RATE = 57600
+
+  COLOR_RED    = 0
+  COLOR_ORANGE = 1
+  COLOR_YELLOW = 2
+  COLOR_GREEN  = 3
+  COLOR_BLUE   = 4
+  COLOR_PURPLE = 5
+
+  PULSE_NONE = 0
+  PULSE_SLOW = 1
+  PULSE_MED  = 2
+  PULSE_FAST = 3
+
+  BRIGHTNESS_MIN = 0
+  BRIGHTNESS_MED = 1
+  BRIGHTNESS_MAX = 2
+
+  def initialize(options = {})
+    @opts = options
+  end
+
+  def device
+    @device ||= begin
+      dev = @opts[:device] || autodetect_device
+
+      unless dev && File.exist?(dev) && File.stat(dev).chardev?
+        raise ArgumentError, 'invalid device'
+      end
+
+      logger.info("selected device #{dev}")
+
+      dev
+    end
+  end
+
+  def logger
+    @logger ||= begin
+      @opts[:logger] || Logger.new(nil)
+    end
+  end
+
+  def update(color, pulse)
+    if (color < 0 || color > 5)
+      raise ArgumentError, 'color must be between 0 and 5'
+    end
+
+    if (pulse < 0 || pulse > 3)
+      raise ArgumentError, 'pulse must be between 0 and 3'
+    end
+
+    logger.info("updating with color=#{color}, pulse=#{pulse}")
+
+    send((65 + (color * 4) + pulse).chr)
+  end
+
+  def setBrightness(brightness)
+    if (brightness < 0 || brightness > 2)
+      raise ArgumentError, 'brightness must be between 0 and 2'
+    end
+
+    logger.info("setting brightness=#{brightness}")
+
+    send((65 + 32 + brightness).chr)
+  end
+
+  private
+
+  def autodetect_device
+    devices = Dir.glob('/dev/*.usbmodem*') + Dir.glob('/dev/*.usbserial*')
+
+    devices.each do |dev|
+      logger.debug("autodetect_device found #{dev}")
+    end
+
+    devices.first
+  end
+
+  def send(command)
+    SerialPort.open(device, SERIAL_PORT_BAUD_RATE) do |serial_port|
+      logger.debug("send \"#{command}\"")
+      serial_port.write(command)
+    end
+  end
+
+end

data/lib/blinkytape-orb/version.rb

@@ -0,0 +1,3 @@
+class BlinkyTapeOrb
+  VERSION = '0.0.1'
+end

data/spec/lib/blinkytape-orb_spec.rb

@@ -0,0 +1,145 @@
+require 'spec_helper'
+
+describe BlinkyTapeOrb do
+
+  let (:options) { {} }
+  let (:orb) { BlinkyTapeOrb.new(options) }
+
+  describe '#device' do
+
+    context 'with valid device option' do
+      let (:options) { { :device => '/dev/zero' } }
+
+      it 'returns device' do
+        expect(orb.device).to eq('/dev/zero')
+      end
+    end
+
+    context 'with non-existent device' do
+      let (:options) { { :device => '/dev/nosuchdevice' } }
+
+      it 'raises ArgumentError' do
+        expect {
+          orb.device
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with block device' do
+      let (:options) { { :device => `df #{__FILE__} | tail -1 | cut -d ' ' -f 1` } }
+
+      it 'raises ArgumentError' do
+        expect {
+          orb.device
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with autodetected device' do
+      it 'returns first device matching pattern' do
+        expect(Dir).to receive(:glob).twice.and_return(['/dev/urandom', '/dev/random'])
+        expect(orb.device).to eq('/dev/urandom')
+      end
+    end
+
+  end
+
+  describe '#update' do
+
+    let (:color) { BlinkyTapeOrb::COLOR_RED }
+    let (:pulse) { BlinkyTapeOrb::PULSE_NONE }
+
+    context 'with out of range color' do
+      let (:color) { 6 }
+
+      it 'raises ArgumentError' do
+        expect {
+          orb.update(color, pulse)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with out of range pulse' do
+      let (:pulse) { 4 }
+
+      it 'raises ArgumentError' do
+        expect {
+          orb.update(color, pulse)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with valid arguments' do
+      it 'sends correct update' do
+        expect(orb).to receive(:send).with('A')
+        orb.update(color, pulse)
+      end
+    end
+
+    context 'with purple color' do
+      let (:color) { BlinkyTapeOrb::COLOR_PURPLE }
+
+      it 'sends correct update' do
+        expect(orb).to receive(:send).with('U')
+        orb.update(color, pulse)
+      end
+    end
+
+    context 'with fast pulse' do
+      let (:pulse) { BlinkyTapeOrb::PULSE_FAST }
+
+      it 'sends correct update' do
+        expect(orb).to receive(:send).with('D')
+        orb.update(color, pulse)
+      end
+    end
+
+  end
+
+  describe '#setBrightness' do
+
+    let (:brightness) { BlinkyTapeOrb::BRIGHTNESS_MAX }
+
+    context 'with out of range brightness' do
+      let (:brightness) { 3 }
+
+      it 'raises ArgumentError' do
+        expect {
+          orb.setBrightness(brightness)
+        }.to raise_error(ArgumentError)
+      end
+    end
+
+    context 'with valid arguments' do
+      it 'sends correct update' do
+        expect(orb).to receive(:send).with('c')
+        orb.setBrightness(brightness)
+      end
+    end
+
+    context 'with min brightness' do
+      let (:brightness) { BlinkyTapeOrb::BRIGHTNESS_MIN }
+
+      it 'sends correct update' do
+        expect(orb).to receive(:send).with('a')
+        orb.setBrightness(brightness)
+      end
+    end
+
+  end
+
+  describe '#send' do
+
+    let (:options) { { :device => '/dev/zero' } }
+    let (:io) { IO.new }
+
+    it 'sends commands' do
+      io = double('serial_port')
+      expect(io).to receive(:write).with('A')
+      expect(SerialPort).to receive(:open).and_yield(io)
+      orb.update(BlinkyTapeOrb::COLOR_RED, BlinkyTapeOrb::PULSE_NONE)
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter 'spec'
+end
+
+SimpleCov.use_merging false
+
+require 'blinkytape-orb'
+
+RSpec.configure do |config|
+  config.color = true
+end

metadata

@@ -0,0 +1,70 @@
+--- !ruby/object:Gem::Specification
+name: blinkytape-orb
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Jon Tai
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-01-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 1.3.1
+description: Other hardware (e.g., arduino) may be supported with minor firmware modifications
+email:
+- jon.tai@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.md
+- arduino/blinkytape_orb.ino
+- blinkytape-orb.gemspec
+- lib/blinkytape-orb.rb
+- lib/blinkytape-orb/version.rb
+- spec/lib/.blinkytape-orb_spec.rb.swp
+- spec/lib/blinkytape-orb_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/jtai/blinkytape-orb
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.0
+signing_key: 
+specification_version: 4
+summary: Ruby code to interface with BlinkyTape controller board running custom firmware
+test_files:
+- spec/lib/.blinkytape-orb_spec.rb.swp
+- spec/lib/blinkytape-orb_spec.rb
+- spec/spec_helper.rb