ir_ptz 0.0.1

data/.gitignore

@@ -0,0 +1,18 @@
+*.gem
+*.rbc
+.bundle
+.config
+coverage
+InstalledFiles
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+
+# YARD artifacts
+.yardoc
+_yardoc
+doc/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in fuci.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,42 @@
+PATH
+  remote: .
+  specs:
+    ir_ptz (0.0.1)
+      arduino_ir_remote (~> 0.1.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    arduino_ir_remote (0.1.1)
+      args_parser (>= 0.2.0)
+      event_emitter
+      serialport
+    args_parser (0.2.0)
+    bourne (1.5.0)
+      mocha (>= 0.13.2, < 0.15)
+    diff-lcs (1.2.4)
+    event_emitter (0.2.5)
+    metaclass (0.0.1)
+    mocha (0.14.0)
+      metaclass (~> 0.0.1)
+    rake (10.1.0)
+    rspec (2.14.1)
+      rspec-core (~> 2.14.0)
+      rspec-expectations (~> 2.14.0)
+      rspec-mocks (~> 2.14.0)
+    rspec-core (2.14.5)
+    rspec-expectations (2.14.3)
+      diff-lcs (>= 1.1.3, < 2.0)
+    rspec-mocks (2.14.3)
+    serialport (1.1.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bourne
+  bundler (~> 1.3)
+  ir_ptz!
+  mocha
+  rake
+  rspec

data/LICENSE

@@ -0,0 +1,20 @@
+The MIT License (MIT)
+
+Copyright (c) 2013 Will Mernagh
+
+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,42 @@
+## IR PTZ
+
+CLI to controle a Pan, Tilt, and Zoom Camera by InfraRed via an Arduino. This
+is just a wrapper around
+[arduino_ir_remote](https://github.com/shokai/arduino_ir_remote) that adds the following:
+
+ - cli to replay recorded codes
+ - ability to record new codes
+
+## Requirements
+
+* Arduino Uno
+* [IR Shield](http://store.linksprite.com/linksprite-infrared-shield-for-arduino/) or IR LED and an IR Reviever
+* USB cable (printer cabel)
+
+## Hardware Installation
+
+* Connect the shield to the Arduino
+* Connect arduino via USB to yoru computer
+
+Note if you are not using a shield the IR LED should be connected to PIN 3 and
+the IR Receiver should be connected to PIN 11
+
+## Software installation
+
+Install this gem
+
+    $ gem install ir_ptz
+
+You will need to install the Arduino SDK and load the sketch from this gem. To
+find the sketch run the following:
+
+    $ gem contents ir_ptz | grep arduino.ino
+    /PATH_TO_GEMS/1.9.1/gems/ir_ptz-x.x.x/arduino/arduino.ino
+
+Then in the SDK open the output from above (e.g. `/PATH_TO_GEMS/1.9.1/gems/ir_ptz-x.x.x/arduino/arduino.ino`)
+
+## Still to do
+
+Have writing to the Arduino not stop processing incoming key presses. Basically
+I will buffer the input in one thread and write out the buffer in the other I
+think.

data/Rakefile

@@ -0,0 +1,6 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')
+
+# If you want to make this the default task
+task :default => :spec

data/arduino/arduino.ino

@@ -0,0 +1,118 @@
+#define IR_DATA_SIZE 768
+byte ir_data[IR_DATA_SIZE];
+unsigned int ir_index;
+#define PIN_LED 13
+#define PIN_IR_IN 11
+#define PIN_IR_OUT 3
+
+void setup(){
+  Serial.begin(57600);
+  pinMode(PIN_IR_IN, INPUT);
+  pinMode(PIN_IR_OUT, OUTPUT);
+  pinMode(PIN_LED, OUTPUT);
+}
+
+unsigned int analog_count = 0;
+void loop(){
+  if(Serial.available()){
+    char recv = Serial.read();
+    process_input(recv);
+  }
+  else{
+    if(analog_count < 1){
+      for(byte i = 0; i < 6; i++){
+        Serial.print("ANALOG");
+        Serial.println(i);
+        Serial.println(analogRead(i));
+      }
+    }
+    analog_count += 1;
+    if(analog_count > 65534) analog_count = 0;
+  }
+}
+
+void ir_read(byte ir_pin){
+  unsigned int i, j;
+  for(i = 0; i < IR_DATA_SIZE; i++){
+    ir_data[i] = 0;
+  }
+  unsigned long now, last, start_at;
+  boolean stat;
+  start_at = micros();
+  while(stat = digitalRead(ir_pin)){
+    if(micros() - start_at > 2500000) return;    
+  }
+  start_at = last = micros();
+  for(i = 0; i < IR_DATA_SIZE; i++){
+    for(j = 0; ; j++){
+      if(stat != digitalRead(ir_pin)) break;
+      if(j > 65534) return;
+    }
+    now = micros();
+    ir_data[i] = (now - last)/100;
+    last = now;
+    stat = !stat;
+  }
+}
+
+void ir_print(){
+  unsigned int i;
+  for(i = 0; i < IR_DATA_SIZE; i++){
+    Serial.print(ir_data[i]);
+    if(ir_data[i] < 1) break;
+    Serial.print(",");
+  }
+  Serial.println();
+}
+
+void ir_write(byte ir_pin){
+  unsigned int i;
+  unsigned long interval_sum, start_at;
+  interval_sum = 0;
+  start_at = micros();
+  for(i = 0; i < IR_DATA_SIZE; i++){
+    if(ir_data[i] < 1) break;
+    interval_sum += ir_data[i] * 100;
+    if(i % 2 == 0){
+      while(micros() - start_at < interval_sum){
+        digitalWrite(ir_pin, true);
+        delayMicroseconds(6);
+        digitalWrite(ir_pin, false);
+        delayMicroseconds(8);
+      }
+    }
+    else{
+      while(micros() - start_at < interval_sum);
+    }
+  }
+}
+
+void process_input(char input){
+  if(input == 'r'){
+    digitalWrite(PIN_LED, true);
+    ir_read(PIN_IR_IN);
+    Serial.println("READ");
+    ir_print();
+    digitalWrite(PIN_LED, false);
+  }
+  else if(input == 'w'){
+    for(ir_index = 0; ir_index < IR_DATA_SIZE; ir_index++){
+      ir_data[ir_index] = 0;
+    }
+    ir_index = 0;
+  }
+  else if(input == ','){
+    if(ir_index < IR_DATA_SIZE) ir_index += 1;
+  }
+  else if(input >= '0' && '9' >= input){
+    ir_data[ir_index] = ir_data[ir_index]*10 + (input - '0');
+  }
+  else if(input == 'W'){
+    digitalWrite(PIN_LED, true);
+    ir_write(PIN_IR_OUT);
+    ir_index = 0;
+    Serial.println("WRITE");
+    ir_print();
+    digitalWrite(PIN_LED, false);
+  }
+}

data/bin/ir_ptz

@@ -0,0 +1,13 @@
+#!/usr/bin/env ruby
+require 'fileutils'
+
+DATA_FILE = ENV["IR_DATA_FILE"] || File.expand_path('.ir_remote.yml', ENV['HOME'])
+unless File.exists?(DATA_FILE)
+  default_file = File.join(File.dirname(File.expand_path(__FILE__)), '../data/ir_remote.yml')
+  FileUtils.cp default_file, DATA_FILE
+end
+
+require 'ir_ptz'
+require 'ir_ptz/command_line'
+
+IrPtz::CommandLine.new.run

data/data/ir_remote.yml

@@ -0,0 +1,16 @@
+---
+actions:
+  tilt_up: '89,44,5,5,5,16,5,5,5,5,5,5,5,5,5,5,5,5,5,16,5,5,5,16,5,16,5,16,5,16,5,16,5,16,5,5,5,5,5,16,5,5,5,16,5,16,5,5,5,16,5,16,5,16,5,5,5,16,5,5,5,5,5,16,5,5,5,143,89,22,5,192,89,22,5,192,89,22,5,192,89,22,5,192,89,22,5,0'
+  tilt_down: '90,44,6,4,6,16,6,4,6,4,6,4,6,4,6,4,6,4,6,16,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,4,6,16,6,16,6,16,6,16,6,4,6,16,6,16,6,16,6,4,6,4,6,4,6,4,6,16,6,4,6,142,90,21,6,0'
+  pan_right: '90,44,6,4,6,16,6,4,6,4,6,4,6,4,6,4,6,4,6,16,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,4,6,4,6,4,6,4,6,4,6,142,90,21,6,0'
+  pan_left: '90,44,6,4,6,16,6,4,6,4,6,4,6,4,6,4,6,4,6,16,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,4,6,16,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,16,6,4,6,4,6,4,6,4,6,0'
+  zoom_in: '90,44,6,4,6,16,6,4,6,4,6,4,6,4,6,4,6,4,6,16,6,4,6,16,6,16,6,16,6,16,6,16,6,16,6,4,6,16,6,4,6,4,6,4,6,16,6,4,6,16,6,16,6,4,6,16,6,16,6,16,6,4,6,16,6,4,6,142,90,21,6,0'
+  zoom_out: '89,44,5,5,5,16,5,5,5,5,5,5,5,5,5,5,5,5,5,16,5,5,5,16,5,16,5,16,5,16,5,16,5,16,5,5,5,16,5,5,5,5,5,5,5,16,5,16,5,16,5,16,5,5,5,16,5,16,5,16,5,5,5,5,5,5,5,143,89,22,5,0'
+action_mappings:
+  k: tilt_up
+  j: tilt_down
+  l: pan_right
+  h: pan_left
+  i: zoom_in
+  o: zoom_out
+device_path: /dev/tty.usbmodem401321

data/ir_ptz.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ir_ptz/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ir_ptz"
+  spec.version       = IrPtz::VERSION
+  spec.authors       = ["Will Mernagh"]
+  spec.email         = ["wmernagh@gmail.com"]
+  spec.description   = %q{CLI to control a Pan Tilt Zoom Camera by InfraRed via an Arduino}
+  spec.summary       = %q{see homepage}
+  spec.homepage      = "https://github.com/wmernagh/ir_ptz"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "arduino_ir_remote", "~> 0.1.1"
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "mocha"
+  spec.add_development_dependency "bourne"
+end

data/lib/ir_ptz.rb

@@ -0,0 +1,43 @@
+require 'bundler/setup'
+
+module IrPtz
+  class << self
+    attr_accessor :configuration
+  end
+
+  # Configure IrPtz in ~/.ir_ptz_config.rb to override the defaults
+  #
+  # @example
+  #   IrPtz.configure do |config|
+  #     config.device_path = '/dev/tty.usbmodem9999'
+  #     config.in_key      = 'a'
+  #     config.out_key     = 's'
+  #   end
+  def self.configure
+    yield(configuration) if block_given?
+  end
+
+  def self.configuration
+      @configuration ||= Configuration.new
+  end
+
+  class Configuration
+    attr_accessor :escape_key, :help_key, :record_key, :actions, :action_mappings
+    attr_accessor :device_path
+
+    def initialize
+      self.escape_key  = 'e'
+      self.help_key    = '?'
+      self.record_key  = 'r'
+      self.action_mappings = ArduinoIrRemote::DATA['action_mappings']
+      self.actions         = ArduinoIrRemote::DATA['actions']
+      self.device_path     = ArduinoIrRemote::DATA['device_path']
+    end
+  end
+end
+
+require "ir_ptz/version"
+require 'arduino_ir_remote'
+require "ir_ptz/ir_remote"
+require "ir_ptz/ir_command_recorder"
+require "ir_ptz/command_line"

data/lib/ir_ptz/command_line.rb

@@ -0,0 +1,62 @@
+require 'io/console'
+
+module IrPtz
+  class CommandLine
+    attr_reader :ir_remote
+
+    def initialize
+      # ensure_configured
+      @ir_remote = IrRemote.instance
+    end
+
+    def run
+      print_instructions
+
+      while key = STDIN.getch
+        case key
+        when config.escape_key
+          puts 'Goodbye!'
+          break
+        when config.help_key
+          print_instructions
+        when config.record_key
+          ir_command_recorder.record.save
+        else
+          if action = action(key)
+            ir_remote.send action(key)
+          else
+            print_instructions
+          end
+        end
+      end
+    end
+
+    private
+
+    def ir_command_recorder
+      IrCommandRecorder
+    end
+
+    def action(key)
+      config.action_mappings[key]
+    end
+
+    def config
+      IrPtz.configuration
+    end
+
+    def print_instructions
+      puts instructions
+    end
+
+    def instructions
+      title        = "\nThe following key commands are available:\n"
+      exit_text    = "\t'#{config.escape_key}' to exit."
+      help_text    = "\t'#{config.help_key}' for help"
+      record_text  = "\t'#{config.record_key}' record a new command"
+      custom_text  = config.action_mappings.map { |k, v| "\t'#{k}' to #{v}" }
+      instructions = [title, exit_text, help_text, record_text] + custom_text
+      instructions.join "\n"
+    end
+  end
+end

data/lib/ir_ptz/ir_command_recorder.rb

@@ -0,0 +1,63 @@
+require 'io/console'
+
+module IrPtz
+  class IrCommandRecorder
+    Command = Struct.new(:title, :key, :action_code) do
+      def save
+        ArduinoIrRemote::DATA['action_mappings'][key] = title
+        ArduinoIrRemote::DATA['actions'][title] = action_code
+        ArduinoIrRemote::DATA.save
+        puts "#{title} saved!"
+      end
+    end
+
+    def self.record
+      command = nil
+      title   = get_title
+      key     = get_key
+      code    = get_ir_code
+
+      @command = Command.new(title, key, code)
+    end
+
+    private
+    class BlankException < Exception; end
+    NON_WHITESPACE_REGEXP = %r![^\s#{[0x3000].pack("U")}]!
+
+    def self.blank?(string)
+      res = string !~ NON_WHITESPACE_REGEXP
+    end
+
+    def self.get_title
+      print 'Enter command title: '
+      title = gets.chomp
+
+      if IrPtz.configuration.actions.has_key? title
+        puts %Q{overwrite "#{title}" ?}
+        print "[Y/n] > "
+        return nil unless gets.strip =~ /Y/
+      end
+
+      blank?(title) ? get_title : title
+    end
+
+    def self.get_key
+      puts 'Enter the key to be used to send the command: '
+      key = getch
+
+      if IrPtz.configuration.action_mappings.has_key? key
+        puts %Q{overwrite "#{args[:read]}" ?}
+        print "[Y/n] > "
+        return nil unless gets.strip =~ /Y/
+      end
+
+      blank?(key) ? get_key : key
+    end
+
+    def self.get_ir_code
+      ir_code = IrRemote.instance.read_code
+      blank?(ir_code) ? get_ir_code : ir_code
+    end
+    private_class_method :get_ir_code
+  end
+end

data/lib/ir_ptz/ir_remote.rb

@@ -0,0 +1,40 @@
+require 'arduino_ir_remote'
+require 'singleton'
+
+module IrPtz
+  class IrRemote
+    include Singleton
+
+    IrPtz.configuration.actions.keys.each do |action|
+      define_method(action) do
+        if ir_code = IrPtz.configuration.actions[action]
+          ir.write ir_code
+        end
+      end
+    end
+
+    def read_code
+      data = nil
+      end_of_read = nil
+
+      ir.read do |ir_data|
+        data = ir_data
+        end_of_read = true
+      end
+
+      puts "reading.."
+      ir.wait { sleep 1; break if end_of_read }
+      puts "finished reading!"
+
+      data
+    end
+
+    private
+
+    attr_reader :ir
+
+    def initialize
+      @ir = ArduinoIrRemote.connect IrPtz.configuration.device_path
+    end
+  end
+end

data/lib/ir_ptz/version.rb

@@ -0,0 +1,3 @@
+module IrPtz
+  VERSION = "0.0.1"
+end

data/spec/helpers.rb

@@ -0,0 +1,16 @@
+module Helpers
+  def expect_key_delegates_to_remote(key, command)
+    escape_key = IrPtz.configuration.escape_key
+    STDIN.stubs(:getch).returns key, escape_key
+
+    ir_remote = mock
+    IrPtz::IrRemote.stubs(:new).returns ir_remote
+    ir_remote.stubs(command)
+
+    cli = IrPtz::CommandLine.new
+    cli.stubs(:puts)
+    cli.run
+
+    # expect(ir_remote).to have_received(command)
+  end
+end

data/spec/ir_ptz/command_line_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+require 'ir_ptz'
+require 'ir_ptz/ir_remote'
+
+describe IrPtz::CommandLine do
+  context 'non remote commands' do
+    let(:escape_key) { IrPtz.configuration.escape_key }
+    let(:record_key) { IrPtz.configuration.record_key }
+    let(:bad_key)    { '.' }
+    let(:getch_stub) { STDIN.stubs(:getch) }
+    subject(:cli)    { IrPtz::CommandLine.new }
+
+    describe '#run' do
+      before { cli.stubs(:puts) }
+
+      it 'prints the instructions' do
+        instructions = cli.send(:instructions)
+        getch_stub.returns escape_key
+
+        cli.run
+
+        expect(cli).to have_received(:puts).with(instructions)
+      end
+
+      it 'listens for the escape key and exits upon receipt' do
+        getch_stub.returns escape_key
+
+        cli.run
+
+        expect(cli).to have_received(:puts).with('Goodbye!')
+      end
+
+      it 'prints the instruction when a bad key is pressed' do
+        instructions = cli.send(:instructions)
+        getch_stub.returns bad_key, escape_key
+
+        cli.run
+
+        # twice - once at the start and once for the bad key
+        expect(cli).to have_received(:puts).with(instructions).twice
+      end
+
+      it 'loops until the escape key is pressed' do
+        instructions = cli.send(:instructions)
+        getch_stub.returns bad_key, bad_key, escape_key
+
+        cli.run
+
+        # trice - once at the start and once for each bad key press
+        expect(cli).to have_received(:puts).with(instructions).times(3)
+      end
+
+      it 'passes record_new_command to IRCommandRecorder' do
+        IrPtz::IrCommandRecorder.stubs(:record).returns(mock(:save))
+        getch_stub.returns record_key, escape_key
+
+        cli.run
+
+        expect(IrPtz::IrCommandRecorder).to have_received(:record)
+      end
+    end
+
+    context 'remote specific commands' do
+      IrPtz.configuration.action_mappings.keys.each do |key|
+        it 'passes commands to IR Remote' do
+          IrPtz::IrRemote.instance.stubs(:read_code)
+
+          expect_key_delegates_to_remote key, IrPtz.configuration.action_mappings[key]
+        end
+      end
+    end
+  end
+end

data/spec/ir_ptz/ir_command_recorder_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+require 'ir_ptz'
+
+describe IrPtz::IrCommandRecorder do
+  describe '#record' do
+    subject(:recorder) { IrPtz::IrCommandRecorder }
+    let(:title) { "xxx\n" }
+    let(:confirmation) { '' }
+
+
+    before do
+      recorder.stubs(:puts)
+      recorder.stubs(:print)
+      recorder.stubs(:getch).returns("x")
+      recorder.stubs(:gets).returns(title, confirmation)
+    end
+
+    describe '.get_title' do
+      it 'asks the user to enter the command title' do
+        recorder.get_title
+        expect(recorder).to have_received(:print).with 'Enter command title: '
+      end
+
+      it 'reads in the command title' do
+        expect(recorder.get_title).to eql 'xxx'
+      end
+
+      context 'title already exists' do
+        let(:title) { "zoom_in\n" }
+        let(:confirmation) { 'Y' }
+
+        it 'asks if you want to override it' do
+          recorder.get_title
+          expect(recorder).to have_received(:puts).with 'overwrite "zoom_in" ?'
+          expect(recorder).to have_received(:print).with '[Y/n] > '
+        end
+
+        it 'returns the key if you enter Y' do
+          expect(recorder.get_title).to eql title.chomp
+        end
+
+        context 'you do not enter Y' do
+          let(:confirmation) { 'r' }
+
+          it 'returns nil' do
+            expect(recorder.get_title).to eql nil
+          end
+        end
+      end
+    end
+
+    it 'creates a new command' do
+      IrPtz::IrRemote.stubs(:instance).returns mock(read_code: '93,44')
+      ir_command = IrPtz::IrCommandRecorder::Command.new('xxx', 'x', '93,44')
+      expect(recorder.record).to eql ir_command
+    end
+  end
+end

data/spec/ir_ptz/ir_remote_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'ir_ptz'
+require 'arduino_ir_remote'
+
+describe IrPtz::IrRemote do
+  subject(:ir)     { IrPtz::IrRemote.instance }
+  let(:arduino_ir) { mock }
+
+  before do
+    ir.stubs(:ir).returns arduino_ir
+  end
+
+  # concrete example
+  describe 'zoom_in' do
+    before do
+      arduino_ir.stubs(:write)
+      ArduinoIrRemote::DATA['actions']['zoom_in'] = 'some value'
+    end
+
+    it 'sends the zoom in signal to the board' do
+      ir.zoom_in
+      expect(arduino_ir).to have_received(:write).with 'some value'
+    end
+  end
+
+  # dynamic example
+  ArduinoIrRemote::DATA['actions'].keys.each do |action|
+    describe 'actions' do
+      before do
+        ArduinoIrRemote::DATA['actions'][action] = 'some value'
+        arduino_ir.stubs(:write)
+      end
+
+      it 'can send a defined singnal to the board' do
+        ir.send(action)
+        expect(arduino_ir).to have_received(:write).with 'some value'
+      end
+    end
+  end
+
+  describe '#read_code' do
+    it 'returns the read in signal'
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,11 @@
+require 'mocha/api'
+require 'bourne'
+require 'helpers'
+
+data_file = File.join(File.dirname(File.expand_path(__FILE__)), '../data/ir_remote.yml')
+ENV["IR_DATA_FILE"] = data_file
+
+RSpec.configure do |config|
+  config.mock_with :mocha
+  config.include Helpers
+end

metadata

@@ -0,0 +1,168 @@
+--- !ruby/object:Gem::Specification
+name: ir_ptz
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Will Mernagh
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-29 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: arduino_ir_remote
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.1.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bourne
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: CLI to control a Pan Tilt Zoom Camera by InfraRed via an Arduino
+email:
+- wmernagh@gmail.com
+executables:
+- ir_ptz
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- Rakefile
+- arduino/arduino.ino
+- bin/ir_ptz
+- data/ir_remote.yml
+- ir_ptz.gemspec
+- lib/ir_ptz.rb
+- lib/ir_ptz/command_line.rb
+- lib/ir_ptz/ir_command_recorder.rb
+- lib/ir_ptz/ir_remote.rb
+- lib/ir_ptz/version.rb
+- spec/helpers.rb
+- spec/ir_ptz/command_line_spec.rb
+- spec/ir_ptz/ir_command_recorder_spec.rb
+- spec/ir_ptz/ir_remote_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/wmernagh/ir_ptz
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.23
+signing_key: 
+specification_version: 3
+summary: see homepage
+test_files:
+- spec/helpers.rb
+- spec/ir_ptz/command_line_spec.rb
+- spec/ir_ptz/ir_command_recorder_spec.rb
+- spec/ir_ptz/ir_remote_spec.rb
+- spec/spec_helper.rb