ruby_buzz 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 13ed3645ae22adbdf04423671b8caf8103114680
+  data.tar.gz: 96e818999e882cd82d77bd8a120a782444cc3c95
+SHA512:
+  metadata.gz: 4310f00d7c22788182ff3e39efc430315e7d3c81242e36c54cbc1d5d99eb1246e63968c724a625e41cd95e94e7269a49e79f159275cfd498f67046c98a64b775
+  data.tar.gz: 6732307f59e5db47647edf35c0b950c9dde5c509b6755f142bf528b68085d874ccb4d9b953acc1abd7962c526481c0c64b1f613a9e7928f6fb0e1cce0a24f828

data/LICENCE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 Andrew Faraday
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,189 @@
+ruby-buzz
+==========
+
+A Ruby library for controlling the LEDs on buzz controllers in Linux.
+
+* Linux only
+* Wired buzz controllers only
+
+*Warning:* ruby_buzz has to change some rights down in the /sys and /dev
+folders of Linux in order to access the kernel. You will be asked for
+your password in order to use ruby_buzz.
+
+Example Scripts
+===============
+
+The scripts folder contains examples of the input and output
+functionality for the buzz controllers.
+
+Turn on buzzer 1
+
+`ruby scripts/light.rb 1 on`
+
+-------------
+
+Turn off buzzer 1
+
+`ruby scripts/light.rb 1 off`
+
+-------------
+
+Watch the inputs
+
+`ruby scripts/read.rb`
+
+(press ctrl+c to stop)
+
+-------------
+
+Pushing the buzzer lights that buzzer 
+
+`ruby scripts/events.rb`
+
+(press ctrl+c to stop)
+
+
+Using it in your code
+=====================
+
+Lights
+------
+
+Include the ruby_buzz library
+
+`require 'ruby_buzz'`
+
+The Buzz controller has 4 pads, each of which has four lights.
+They can be accessed like so:
+
+```ruby
+# Via the pads
+RubyBuzz::Pad[0]
+RubyBuzz::Pad[0].light
+RubyBuzz::Pad.all
+# A control for light 1, divorced from the pad.
+RubyBuzz::Light.new(0)
+```
+
+Control one light:
+
+```ruby
+pad = RubyBuzz::Pad[0]
+pad.light.on
+sleep 1
+pad.light.off
+```
+
+A quick light show
+
+```ruby
+RubyBuzz::Pad.all.each do |pad|
+  pad.light.on
+  sleep 0.1
+end 
+RubyBuzz::Pad.all.each do |pad|
+  pad.light.off
+  sleep 0.1
+end 
+```
+
+If you abandon your script before all the lights are turned off they
+will say on indefinitely. You may want to rescue SystemExit and Interrupt
+errors with `RubyBuzz::Light.all_off` E.g.
+
+```ruby
+begin
+  loop do
+    RubyBuzz::Pad[rand(4)].light.on
+    RubyBuzz::Pad[rand(4)].light.off
+    sleep 0.1
+  end 
+rescue SystemExit, Interrupt
+  RubyBuzz::Light.all_off
+end
+```
+
+Button events
+-------------
+
+Include the ruby_buzz library
+
+`require 'ruby_buzz'`
+
+The Buzz controller has 4 pads, each of which has four buttons named:
+ 
+ * buzz
+ * blue
+ * orange
+ * green
+ * yellow
+
+They can be found like this:
+
+```ruby
+RubyBuzz::Pad[0]
+RubyBuzz::Pad[0].buttons
+RubyBuzz::Pad[0].buttons[:buzz]
+RubyBuzz::Pad.all
+```
+
+You can define a block of code to be run by a given button like this:
+
+```ruby
+RubyBuzz::Pad[0].add_event(
+  :buzz,
+  lambda {
+    puts "Player 1 buzzed!"
+  }
+)
+```
+
+You can debug the actions you've added to a button with trigger_events
+
+```ruby
+RubyBuzz::Pad[0].trigger_events
+```
+
+How about getting it to run when you press the button?
+
+The RubyBuzz::Device class is responsible for reading the raw input
+from the Buzz controllers via the linux terminal. Because it's reading
+a data stream, it needs to start a background process to allow it to 
+work while other ruby code is operating.
+
+You can start background process, which executes the events you added
+to the buttons, with start_watching.
+
+```ruby
+device = RubyBuzz::Device.new
+RubyBuzz::Pad.all.each do |pad|
+  pad.add_event(:buzz, lambda { puts "Buzz!" }
+)
+device.start_watching
+```
+
+Note: This process will end when your ruby process ends, but if you
+want to stop it before that stage, you can call `device.stop_watching`
+
+If you want to do nothing other than watch the buttons, you may want
+to follow start_watching with an empty loop.
+
+```ruby
+device = RubyBuzz::Device.new
+RubyBuzz::Pad.all.each do |pad|
+  pad.add_event(:buzz, lambda { puts "Buzz!" }
+)
+device.start_watching
+
+loop do
+
+end 
+```
+
+Acknowledgements
+===============
+
+This repo includes a modified version of the devinput class from
+https://github.com/kamaradclimber/libdevinput
+Which was forked from
+https://github.com/prullmann/libdevinput

data/lib/ruby_buzz/button.rb

@@ -0,0 +1,37 @@
+module RubyBuzz
+  class Button
+
+    @@buttons = []
+
+    # events will be an array of lambdas
+    attr_accessor :name, :code, :events
+
+    def initialize(code, name, pad)
+      @code = code
+      @name = name
+      @pad = pad
+      @events = []
+      @@buttons << self
+    end
+
+    def self.find(code)
+      @@buttons.detect { |b| b.code == code }
+    end
+
+    def add_event(proc)
+      @events << proc
+    end
+
+    def trigger_events
+      @events.each do |event|
+        event.call
+      end
+    end
+
+    def self.trigger_key(code)
+      btn = self.find(code)
+      btn.trigger_events
+    end
+
+  end
+end

data/lib/ruby_buzz/device.rb

@@ -0,0 +1,77 @@
+#!/usr/bin/env ruby
+
+module RubyBuzz
+  class Device
+
+    require 'time'
+
+    # The worker is a thread which is watching the device
+    attr_accessor :worker
+
+    DEFAULT_FILE_NAME = "/dev/input/by-id/usb-Logitech_Logitech_Buzz_tm__Controller_V1-event-if00"
+
+    Event = Struct.new(:tv_sec, :tv_usec, :type, :code, :value)
+    # open Event class and add some convenience methods
+    class Event
+      def time;
+        Time.at(tv_sec)
+      end
+
+      def to_s
+        type_s = type.to_s
+        code_s = code.to_s
+        value_s = value.to_s
+        "#{time.iso8601} type: #{type_s} code: #{code_s} value: #{value_s}"
+      end
+    end
+
+    def initialize(filename=nil)
+      @dev = File.open(filename || DEFAULT_FILE_NAME)
+      @block_size = 24
+    rescue Errno::ENOENT => er
+      puts "Could not find device: are your controllers plugged in?"
+      raise er
+    end
+
+    def format
+      'qqSSl'
+    end
+
+
+    def read
+      bin = @dev.read @block_size
+      Event.new *bin.unpack(format)
+    end
+
+    def each
+      begin
+        loop do
+          event = read
+          next unless event.type == 1
+          next unless event.value == 1
+          yield event
+        end
+      rescue Errno::ENODEV
+      end
+    end
+
+
+    def start_watching
+      return if @worker
+      @worker = Thread.new do
+        loop do
+          event = read
+          next unless event.type == 1
+          next unless event.value == 1
+          RubyBuzz::Button.trigger_key(event.code)
+        end
+      end
+    end
+
+    def stop_watching
+      @worker.kill
+      @worker = nil
+    end
+
+  end
+end

data/lib/ruby_buzz/light.rb

@@ -0,0 +1,33 @@
+module RubyBuzz
+  class Light
+
+    @@lights = []
+    attr_accessor :file
+
+    def initialize(index)
+      @file = `ls /sys/class/leds/*buzz#{index + 1}/brightness`
+      @@lights << self
+    end
+
+    def on
+      `echo 1 > #{file}`
+      return nil
+    end
+
+    def off
+      `echo 0 > #{file}`
+      return nil
+    end
+
+    def self.all_off
+      @@lights.each{|l|l.off}
+      return nil
+    end
+
+    def self.all_on
+      @@lights.each{|l|l.on }
+      return nil
+    end
+
+  end
+end

data/lib/ruby_buzz/pad.rb

@@ -0,0 +1,72 @@
+# Each of these is an individual players controller
+module RubyBuzz
+  class Pad
+
+    # {event_code => button_name}
+    MAPPINGS = [
+      {
+        704 => :buzz,
+        705 => :yellow,
+        706 => :green,
+        707 => :orange,
+        708 => :blue
+      },
+      {
+        709 => :buzz,
+        710 => :yellow,
+        711 => :green,
+        712 => :orange,
+        713 => :blue
+      },
+      {
+        714 => :buzz,
+        715 => :yellow,
+        716 => :green,
+        717 => :orange,
+        718 => :blue
+      },
+      {
+        719 => :buzz,
+        720 => :yellow,
+        721 => :green,
+        722 => :orange,
+        723 => :blue
+      }
+    ]
+
+    attr_accessor :buttons, :light
+
+    def self.init_mappings
+      @@pads = []
+      MAPPINGS.each_with_index do |mapping, index|
+        @@pads << new(mapping, index)
+      end
+    end
+
+    def self.all
+      @@pads
+    end
+
+    def self.[](index)
+      @@pads[index]
+    end
+
+    def initialize(mapping, index)
+      @index = index
+      @buttons = {}
+      @light = RubyBuzz::Light.new(index)
+      mapping.each do |code, name|
+        @buttons[name] = RubyBuzz::Button.new(code, name, self)
+      end
+    end
+
+    def add_event(button_name, proc)
+      @buttons[button_name].add_event proc
+    end
+
+    def trigger_event(button_name)
+      @buttons[button_name].trigger_events
+    end
+
+  end
+end

data/lib/ruby_buzz.rb

@@ -0,0 +1,9 @@
+`sudo chmod 777 /sys/class/leds/*/brightness`
+`sudo chmod 777 /dev/input/event*`
+
+require_relative './ruby_buzz/device.rb'
+require_relative './ruby_buzz/button.rb'
+require_relative './ruby_buzz/light.rb'
+require_relative './ruby_buzz/pad.rb'
+
+RubyBuzz::Pad.init_mappings

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: ruby_buzz
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Andrew Faraday
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-09-19 00:00:00.000000000 Z
+dependencies: []
+description: Light control and button event observers for wired Buzz™ controllers
+  in Ruby on Linux
+email: andrewfaraday@hotmail.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENCE
+- README.md
+- lib/ruby_buzz.rb
+- lib/ruby_buzz/button.rb
+- lib/ruby_buzz/device.rb
+- lib/ruby_buzz/light.rb
+- lib/ruby_buzz/pad.rb
+homepage: https://github.com/AJFaraday/ruby-buzz
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: 2.0.0
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Buzz™ controller support for Ruby in Linux
+test_files: []