usblamp 0.1.1

data/MANIFEST

@@ -0,0 +1,24 @@
+.gitignore
+.rubocop.yml
+.travis.yml
+Gemfile
+LICENSE.md
+MANIFEST
+README.md
+Rakefile
+bin/usblamp
+lib/usblamp.rb
+lib/usblamp/cli.rb
+lib/usblamp/cli/blink.rb
+lib/usblamp/cli/fadein.rb
+lib/usblamp/color.rb
+lib/usblamp/controller.rb
+lib/usblamp/version.rb
+spec/spec_helper.rb
+spec/usblamp/cli_spec.rb
+spec/usblamp/color_spec.rb
+spec/usblamp/controller_spec.rb
+task/manifest.rake
+task/rspec.rake
+task/rubocop.rake
+usblamp.gemspec

data/README.md

@@ -0,0 +1,60 @@
+#WebMail Notifier with Ruby (Dream Cheeky)
+
+[![Build Status](https://travis-ci.org/PierreRambaud/usblamp.png?branch=master)](https://travis-ci.org/PierreRambaud/usblamp)
+
+Ruby script to power the Dreamcheeky USB webmail notifier gadget. <http://www.dreamcheeky.com/webmail-notifier>
+
+##Requirements
+
+- Ruby 1.9.2 or newer
+
+##Installation
+
+Assuming RubyGems isn't down you can install the Gem as following:
+
+```
+$ gem install usblamp
+```
+
+##Usage
+
+```
+Usage: usblamp [COMMAND] [OPTIONS]
+
+Options:
+
+    -v, --version      Shows the current version
+    -r, --red          Red
+    -g, --green        Green
+    -b, --blue         Blue
+    -c, --color        Color
+    -h, --help         Display this help message.
+
+Available commands:
+
+  fadein   Fade in effect
+  blink    Blink effect
+```
+
+##Troubleshooting
+
+Should be run as root unless the necessary udev rules are set.
+Create the file `/etc/udev/rules.d/42-usblamp.rules`
+And add this content by replacing `got` by your username:
+```
+SUBSYSTEM !="usb_device", ACTION !="add", GOTO="datalogger_rules_end"
+SYSFS{idVendor} =="1d34", SYSFS{idProduct} =="0004", SYMLINK+="datalogger"
+MODE="0666", OWNER="got", GROUP="root"
+LABEL="datalogger_rules_end"
+```
+
+## Running tests
+
+Install dependencies:
+
+`$ bundle install`
+
+To run tests:
+`$ bundle exec rake`
+
+

data/Rakefile

@@ -0,0 +1,10 @@
+# -*- coding: utf-8 -*-
+require 'bundler/gem_tasks'
+
+GEMSPEC = Gem::Specification.load('usblamp.gemspec')
+
+Dir['./task/*.rake'].each do |task|
+  import(task)
+end
+
+task default: [:rubocop, :spec]

data/bin/usblamp

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# -*- coding: utf-8 -*-
+
+require File.expand_path('../../lib/usblamp', __FILE__)
+Usblamp::CLI.slop.parse

data/lib/usblamp/cli/blink.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+Usblamp::CLI.slop.command 'blink' do
+  banner 'Usage: usblamp blink [OPTIONS]'
+  description 'Blink effect'
+  separator "\nOptions:\n"
+
+  Usblamp::CLI.slop.options.each do |c|
+    next if c.long == 'version'
+    options << c
+  end
+
+  on :t=, :times=, 'Times', as: Integer, default: 2
+
+  run do |opts, _args|
+    lamp = Usblamp::Controller.new
+    lamp.open
+    lamp.switch_off
+    lamp.blink(opts[:t], lamp.parse(opts))
+  end
+end

data/lib/usblamp/cli/fadein.rb

@@ -0,0 +1,20 @@
+# -*- coding: utf-8 -*-
+Usblamp::CLI.slop.command 'fadein' do
+  banner 'Usage: usblamp fadein [OPTIONS]'
+  description 'Fade in effect'
+  separator "\nOptions:\n"
+
+  Usblamp::CLI.slop.options.each do |c|
+    next if c.long == 'version'
+    options << c
+  end
+
+  on :d=, :delay=, 'Delay', as: Integer, default: 2
+
+  run do |opts, _args|
+    lamp = Usblamp::Controller.new
+    lamp.open
+    lamp.switch_off
+    lamp.fade_in(opts[:d], lamp.parse(opts))
+  end
+end

data/lib/usblamp/cli.rb

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+module Usblamp
+  # CLI mode
+  module CLI
+    ##
+    # Hash containing the default Slop options.
+    #
+    # @return [Hash]
+    #
+    SLOP_OPTIONS = {
+      strict: true,
+      help: true,
+      banner: 'Usage: usblamp [COMMAND] [OPTIONS]'
+    }
+
+    ##
+    # @return [Slop]
+    #
+    def self.slop
+      @slop ||= default_slop
+    end
+
+    ##
+    # @return [Slop]
+    #
+    def self.default_slop
+      Slop.new(SLOP_OPTIONS.dup) do
+        separator "\nOptions:\n"
+
+        on :v, :version, 'Shows the current version' do
+          puts CLI.version_information
+        end
+
+        on :r=, :red=, 'Red', as: Integer
+        on :g=, :green=, 'Green', as: Integer
+        on :b=, :blue=, 'Blue', as: Integer
+        on :c=, :color=, 'Color'
+
+        run do |opts, _args|
+          lamp = Controller.new
+          lamp.open
+          lamp.switch_off
+          lamp.send_color(lamp.parse(opts))
+        end
+      end
+    end
+
+    ##
+    # Returns a String containing some platform/version related information.
+    #
+    # @return [String]
+    #
+    def self.version_information
+      "usblamp v#{VERSION} on #{RUBY_DESCRIPTION}"
+    end
+  end
+end

data/lib/usblamp/color.rb

@@ -0,0 +1,67 @@
+# -*- coding: utf-8 -*-
+# Usblamp module
+module Usblamp
+  # Color class
+  class Color
+    attr_accessor :red, :green, :blue
+    MAX_VALUE = 0x40
+
+    def initialize(red = nil, green = nil, blue = nil)
+      set(red, green, blue)
+    end
+
+    def set(red, green = nil, blue = nil)
+      if red.is_a?(String) && green.nil? && blue.nil?
+        if ['#', '_'].include?(red[0])
+          return define_from_hex(red)
+        else
+          return define_from_string(red)
+        end
+      end
+
+      red = 0 if red.nil?
+      green = 0 if green.nil?
+      blue = 0 if blue.nil?
+
+      @red = define_value(red)
+      @green = define_value(green)
+      @blue = define_value(blue)
+    end
+
+    private
+
+    def define_value(integer)
+      [[0, integer.to_i].max, MAX_VALUE].min
+    end
+
+    def define_from_hex(string)
+      string = string.gsub(/[#_]/, '')
+      fail ArgumentError, 'Wrong length for hexadecimal string' unless
+        [3, 6].include?(string.length.to_i)
+
+      return set(string[0..1].to_i(16),
+                 string[2..3].to_i(16),
+                 string[4..5].to_i(16)
+                 ) if string.length == 6
+
+      set((string[0] * 2).to_i(16),
+          (string[1] * 2).to_i(16),
+          (string[2] * 2).to_i(16)
+          )
+    end
+
+    def define_from_string(string)
+      return set(MAX_VALUE, 0, 0) if string == 'red'
+      return set(0, MAX_VALUE, 0) if string == 'green'
+      return set(0, 0, MAX_VALUE) if string == 'blue'
+      return set(MAX_VALUE, MAX_VALUE, MAX_VALUE) if string == 'white'
+      return set(MAX_VALUE, 0, MAX_VALUE) if string == 'magenta'
+      return set(0, MAX_VALUE, MAX_VALUE) if string == 'cyan'
+      return set(MAX_VALUE, MAX_VALUE, 0) if string == 'yellow'
+      return set(MAX_VALUE / 2, MAX_VALUE / 2, MAX_VALUE / 2) if
+        string == 'purple'
+
+      set(0, 0, 0)
+    end
+  end
+end

data/lib/usblamp/controller.rb

@@ -0,0 +1,110 @@
+# -*- coding: utf-8 -*-
+# Usblamp module
+module Usblamp
+  # Controller class
+  class Controller
+    attr_accessor :device, :color
+
+    VENDOR_ID = 0x1d34
+    PRODUCT_ID = 0x0004
+    INIT_PACKET1 = [0x1F, 0x01, 0x29, 0x00, 0xB8, 0x54, 0x2C, 0x03]
+    INIT_PACKET2 = [0x00, 0x01, 0x29, 0x00, 0xB8, 0x54, 0x2C, 0x04]
+
+    def initialize
+      @device = nil
+      @color = nil
+    end
+
+    def open
+      usb = LIBUSB::Context.new
+      device = usb.devices(idVendor: VENDOR_ID, idProduct: PRODUCT_ID).first
+
+      fail 'Could no find a supported device.' if device.nil?
+      @device = device.open
+      @device.detach_kernel_driver(0) if @device.kernel_driver_active?(0)
+      @device.claim_interface(0)
+      send(INIT_PACKET1)
+      send(INIT_PACKET2)
+    end
+
+    def send(data)
+      return true if @device
+        .control_transfer(
+                          bmRequestType: LIBUSB::REQUEST_TYPE_CLASS |
+                          LIBUSB::RECIPIENT_INTERFACE,
+                          bRequest: LIBUSB::REQUEST_SET_CONFIGURATION,
+                          wValue: 0x81,
+                          wIndex: LIBUSB::ENDPOINT_OUT,
+                          dataOut: data.map(&:chr).reduce(:+),
+                          timeout: 10) == 8
+
+      false
+    end
+
+    def send_color(color)
+      fail TypeError, 'Parameter must be an instance of Color' unless
+        color.is_a?(Color)
+
+      @color = color
+      data = [color.red,
+              color.green,
+              color.blue,
+              0x00,
+              0x00,
+              0x00,
+              0x00,
+              0x05]
+      send(data)
+    end
+
+    def switch_off
+      send_color(Color.new('black'))
+    end
+
+    def parse(args)
+      color = Color.new(args[:c]) unless args[:c].nil?
+      color = Color.new(args[:r], args[:g], args[:b]) if args[:c].nil?
+      color
+    end
+
+    def fade_in(delay, new_color)
+      delay = delay.to_i
+      color = Color.new
+      max_value = [new_color.red, new_color.green, new_color.blue].max
+      (0..max_value).each do |i|
+        sleep((delay.to_f * 1000.to_f / max_value.to_f + 1.to_f) / 1000.to_f)
+        color.red = transition(i,
+                               @color.red,
+                               new_color.red,
+                               max_value)
+        color.green = transition(i,
+                                 @color.green,
+                                 new_color.green,
+                                 max_value)
+        color.blue = transition(i,
+                                @color.blue,
+                                new_color.blue,
+                                max_value)
+        send_color(color)
+      end
+    end
+
+    def blink(times, new_color)
+      (1..times).each do
+        send_color(new_color)
+        sleep 0.5
+        switch_off
+        sleep 0.5
+      end
+    end
+
+    private
+
+    def transition(index, start_point, end_point, maximum)
+      (((start_point.to_f + (end_point.to_f - start_point.to_f)) *
+        (index.to_f + 1.to_f)
+        ) / maximum.to_f
+       ).to_i
+    end
+  end
+end

data/lib/usblamp/version.rb

@@ -0,0 +1,5 @@
+# -*- coding: utf-8 -*-
+# Gemirro Version
+module Usblamp
+  VERSION = '0.1.1'
+end

data/lib/usblamp.rb

@@ -0,0 +1,15 @@
+# -*- coding: utf-8 -*-
+require 'slop'
+require 'libusb'
+
+unless $LOAD_PATH.include?(File.expand_path('../', __FILE__))
+  $LOAD_PATH.unshift(File.expand_path('../', __FILE__))
+end
+
+require 'usblamp/color'
+require 'usblamp/controller'
+require 'usblamp/version'
+
+require 'usblamp/cli'
+require 'usblamp/cli/fadein'
+require 'usblamp/cli/blink'

data/spec/spec_helper.rb

@@ -0,0 +1,8 @@
+# -*- coding: utf-8 -*-
+$LOAD_PATH << File.expand_path('../../lib', __FILE__)
+
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/spec/'
+end

data/spec/usblamp/cli_spec.rb

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'usblamp/cli'
+require 'slop'
+
+# Usblamp tests
+module Usblamp
+  # CLI tests
+  module CLI
+    describe 'CLI' do
+      it 'should return options' do
+        options = CLI.slop
+        expect(options).to be_a(::Slop)
+        expect(options.config[:strict]).to be_truthy
+        expect(options.config[:banner])
+          .to eq('Usage: usblamp [COMMAND] [OPTIONS]')
+        expect(options.to_s)
+          .to match(/-v, --version(\s+)Shows the current version/)
+        expect(options.to_s)
+          .to match(/-h, --help(\s+)Display this help message./)
+
+        version = options.fetch_option(:v)
+        expect(version.short).to eq('v')
+        expect(version.long).to eq('version')
+        expect { version.call }.to output(/usblamp v.* on ruby/).to_stdout
+      end
+
+      it 'should retrieve version information' do
+        expect(CLI.version_information).to eq(
+          "usblamp v#{VERSION} on #{RUBY_DESCRIPTION}"
+        )
+      end
+
+      it 'should change color' do
+        controller = double(open: true,
+                            switch_off: true,
+                            parse: { c: 'blue' },
+                            send_color: true)
+        allow(Controller).to receive(:new).and_return(controller)
+        expect(CLI.slop.parse(c: 'blue')).to eq(c: 'blue')
+      end
+    end
+  end
+end

data/spec/usblamp/color_spec.rb

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'usblamp/color'
+
+# Usblamp module
+module Usblamp
+  describe 'Color' do
+    before(:each) do
+      @color = Color.new
+    end
+
+    it 'should test initialize with color' do
+      color = Color.new(10, 11, 12)
+      expect(color.red).to eq(10)
+      expect(color.green).to eq(11)
+      expect(color.blue).to eq(12)
+    end
+
+    it 'should test const' do
+      expect(Color::MAX_VALUE).to eq(0x40)
+    end
+
+    it 'should set' do
+      @color.set(10, 11, 12)
+      expect(@color.red).to eq(10)
+      expect(@color.green).to eq(11)
+      expect(@color.blue).to eq(12)
+    end
+
+    it 'should set from hex' do
+      @color.set('#112233')
+      expect(@color.red).to eq(17)
+      expect(@color.green).to eq(34)
+      expect(@color.blue).to eq(51)
+      @color.set('_112233')
+      expect(@color.red).to eq(17)
+      expect(@color.green).to eq(34)
+      expect(@color.blue).to eq(51)
+      @color.set('#123')
+      expect(@color.red).to eq(17)
+      expect(@color.green).to eq(34)
+      expect(@color.blue).to eq(51)
+    end
+
+    it 'should set from string' do
+      @color.set('red')
+      expect(@color.red).to eq(64)
+      expect(@color.green).to eq(0)
+      expect(@color.blue).to eq(0)
+      @color.set('green')
+      expect(@color.red).to eq(0)
+      expect(@color.green).to eq(64)
+      expect(@color.blue).to eq(0)
+      @color.set('blue')
+      expect(@color.red).to eq(0)
+      expect(@color.green).to eq(0)
+      expect(@color.blue).to eq(64)
+      @color.set('white')
+      expect(@color.red).to eq(64)
+      expect(@color.green).to eq(64)
+      expect(@color.blue).to eq(64)
+      @color.set('magenta')
+      expect(@color.red).to eq(64)
+      expect(@color.green).to eq(0)
+      expect(@color.blue).to eq(64)
+      @color.set('cyan')
+      expect(@color.red).to eq(0)
+      expect(@color.green).to eq(64)
+      expect(@color.blue).to eq(64)
+      @color.set('yellow')
+      expect(@color.red).to eq(64)
+      expect(@color.green).to eq(64)
+      expect(@color.blue).to eq(0)
+      @color.set('purple')
+      expect(@color.red).to eq(32)
+      expect(@color.green).to eq(32)
+      expect(@color.blue).to eq(32)
+      @color.set('nothing')
+      expect(@color.red).to eq(0)
+      expect(@color.green).to eq(0)
+      expect(@color.blue).to eq(0)
+    end
+
+    it 'should raise error when undefined color' do
+      expect { @color.set('#FF') }.to raise_error ArgumentError
+      expect { @color.set('#FFFF') }.to raise_error ArgumentError
+      expect { @color.set('#FFFFF') }.to raise_error ArgumentError
+    end
+  end
+end

data/spec/usblamp/controller_spec.rb

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+require 'spec_helper'
+require 'libusb'
+require 'usblamp/controller'
+
+# Usblamp module
+module Usblamp
+  describe 'Controller' do
+    before(:each) do
+      @controller = Controller.new
+    end
+
+    it 'should test init' do
+      expect(@controller.device).to be(nil)
+      expect(@controller.color).to be(nil)
+    end
+
+    it 'should test const' do
+      expect(Controller::VENDOR_ID).to eq(0x1d34)
+      expect(Controller::PRODUCT_ID).to eq(0x0004)
+      expect(Controller::INIT_PACKET1)
+        .to eq([31, 1, 41, 0, 184, 84, 44, 3])
+      expect(Controller::INIT_PACKET2)
+        .to eq([0, 1, 41, 0, 184, 84, 44, 4])
+      expect(@controller.device).to eq(nil)
+    end
+
+    it 'should raise when no supported devices found' do
+      device = double(devices: [])
+      allow(LIBUSB::Context).to receive(:new).and_return(device)
+      expect { @controller.open }.to raise_error(RuntimeError)
+    end
+
+    it 'should open device' do
+      handle = spy(open: true,
+                   kernel_driver_active?: true,
+                   detach_kernel_driver: true,
+                   control_transfer: 8)
+      device = double(devices: [double(open: handle)])
+      allow(LIBUSB::Context).to receive(:new).and_return(device)
+      expect(@controller.open).to be_truthy
+      expect(handle).to have_received(:claim_interface).with(0)
+      expect(handle).to have_received(:control_transfer)
+        .with(bmRequestType: 33,
+              bRequest: 9,
+              wValue: 129,
+              wIndex: 0,
+              dataOut: [31, 1, 41, 0, 184, 84, 44, 3].map(&:chr).reduce(:+),
+              timeout: 10)
+      expect(handle).to have_received(:control_transfer)
+        .with(bmRequestType: 33,
+              bRequest: 9,
+              wValue: 129,
+              wIndex: 0,
+              dataOut: [0, 1, 41, 0, 184, 84, 44, 4].map(&:chr).reduce(:+),
+              timeout: 10)
+    end
+
+    it 'should fail send transfer' do
+      device = double(control_transfer: 5)
+      @controller.device = device
+      expect(@controller.send([0])).to be_falsy
+    end
+
+    it 'should test send_color parameter' do
+      expect { @controller.send_color('fake') }
+        .to raise_error(TypeError, 'Parameter must be an instance of Color')
+    end
+
+    it 'should send color' do
+      device = spy(control_transfer: 8)
+      @controller.device = device
+      expect(@controller.send_color(Color.new('blue'))).to be_truthy
+      expect(device).to have_received(:control_transfer)
+        .with(bmRequestType: 33,
+              bRequest: 9,
+              wValue: 129,
+              wIndex: 0,
+              dataOut: [0, 0, 64, 0, 0, 0, 0, 5].map(&:chr).reduce(:+),
+              timeout: 10)
+    end
+
+    it 'should switch off' do
+      device = spy(control_transfer: 8)
+      @controller.device = device
+      expect(@controller.switch_off).to be_truthy
+      expect(device).to have_received(:control_transfer)
+        .with(bmRequestType: 33,
+              bRequest: 9,
+              wValue: 129,
+              wIndex: 0,
+              dataOut: "\x00\x00\x00\x00\x00\x00\x00\x05",
+              timeout: 10)
+    end
+
+    it 'should parse args to create color' do
+      args = { c: 'red' }
+      result = @controller.parse(args)
+      expect(result).to be_a(Color)
+      expect(result.red).to eq(64)
+      expect(result.green).to eq(0)
+      expect(result.blue).to eq(0)
+
+      args = { r: 10, g: 10, b: 10 }
+      result = @controller.parse(args)
+      expect(result).to be_a(Color)
+      expect(result.red).to eq(10)
+      expect(result.green).to eq(10)
+      expect(result.blue).to eq(10)
+    end
+
+    it 'should fade in' do
+      device = spy(control_transfer: 8)
+      @controller.color = Color.new('black')
+      @controller.device = device
+      allow(@controller).to receive(:sleep).and_return(true)
+      expect(@controller.fade_in(2, Color.new('blue'))).to be_truthy
+      (1..64).each do |i|
+        expect(device).to have_received(:control_transfer)
+          .with(bmRequestType: 33,
+                bRequest: 9,
+                wValue: 129,
+                wIndex: 0,
+                dataOut: [0, 0, i, 0, 0, 0, 0, 5].map(&:chr).reduce(:+),
+                timeout: 10)
+      end
+    end
+
+    it 'should blink' do
+      device = spy(control_transfer: 8)
+      @controller.device = device
+      allow(@controller).to receive(:sleep).and_return(true)
+      expect(@controller.blink(2, Color.new('blue'))).to be_truthy
+      (1..2).each do
+        expect(device).to have_received(:control_transfer).twice
+          .with(bmRequestType: 33,
+                bRequest: 9,
+                wValue: 129,
+                wIndex: 0,
+                dataOut: [0, 0, 64, 0, 0, 0, 0, 5].map(&:chr).reduce(:+),
+                timeout: 10)
+        expect(device).to have_received(:control_transfer).twice
+          .with(bmRequestType: 33,
+                bRequest: 9,
+                wValue: 129,
+                wIndex: 0,
+                dataOut: [0, 0, 0, 0, 0, 0, 0, 5].map(&:chr).reduce(:+),
+                timeout: 10)
+      end
+    end
+  end
+end