pi_piper 2.0.beta.4 → 2.0.0

data/lib/pi_piper/stub_driver.rb

@@ -0,0 +1,124 @@
+# @description driver that can be used either with tests or with rails or other frameworks for development
+require_relative 'pin_values'
+
+module PiPiper
+
+  class NullLogger
+    def debug(*) end
+  end
+
+  module StubDriver
+    include PiPiper::PinValues
+    extend self
+
+    def new(options = {})
+      opts = {
+          :logger => NullLogger.new
+      }.merge(options)
+
+      @logger = opts[:logger]
+
+      @pins = {}
+
+      @spi = {data:[], chip_select:0,}
+
+      self
+    end
+    alias_method :reset, :new
+
+
+    def gpio_select_function(pin_number, alt_fun)
+    end
+
+    def pin_input(pin_number)
+      #@pins[pin_number] = { direction: :in }
+      pin(pin_number)[:direction] = :in
+      @logger.debug("Pin ##{pin_number} -> Input")
+    end
+
+    def pin_output(pin_number)
+      #@pins[pin_number] = { direction: :in }
+      pin(pin_number)[:direction] = :out
+      @logger.debug("Pin ##{pin_number} -> Output")
+    end
+
+    def pin_direction(pin_number)
+      pin(pin_number)[:direction] if @pins[pin_number]
+    end
+
+    def pin_set(pin_number, value)
+      pin(pin_number)[:value] = value
+      @logger.debug("Pin ##{pin_number} -> #{value}")
+    end
+
+    def pin_set_pud(pin_number, value)
+      pin(pin_number)[:pud] = value
+      @logger.debug("PinPUD ##{pin_number} -> #{value}")
+    end
+
+    def pwm_clock(clock_divider)
+    end
+
+    def pwm_mode(channel, mode, start)
+    end
+
+    def pwm_range(channel, range)
+    end
+
+    def pwm_data(channel, data)
+    end
+
+    def spidev_out(array)
+      @spi[:data] = array
+      @logger.debug("SPIDEV -> #{array.pack('C*')}")
+    end
+
+    def spi_begin
+      @logger.debug("SPI Begin")
+      @spi[:data] = []
+    end
+
+    def spi_transfer_bytes(data)
+      @logger.debug("SPI CS#{@spi[:chip_select]} <- #{data.to_s}")
+      @spi[:data] = Array(data)
+    end
+
+    def spi_chip_select(chip = nil)
+      chip = chip || @spi[:chip_select]
+      @logger.debug("SPI Chip Select = #{chip}")
+      @spi[:chip_select] = chip
+    end
+
+    def pin_read(pin_number)
+      val = pin(pin_number)[:value]
+      val ||= case pin(pin_number)[:pud]
+                when GPIO_PUD_UP   then GPIO_HIGH
+                when GPIO_PUD_DOWN then GPIO_LOW
+                else nil
+              end
+    end
+
+    def release_pins
+      @pins.keys.each { |pin_number| release_pin(pin_number) }
+    end
+
+    def release_pin(pin_number)
+      @pins.delete(pin_number)
+    end
+
+    def method_missing(meth, *args, &block)
+      puts "Needs Implementation: StubDriver##{meth}"
+    end
+
+    private
+
+    def pin(pin_number)
+      @pins[pin_number] ||= {}
+    end
+
+    ## The following methods are only for testing and are not available on any platforms
+    def spi_data
+      @spi[:data]
+    end   
+  end
+end

data/lib/pi_piper/version.rb

@@ -0,0 +1,3 @@
+module PiPiper
+  VERSION = '2.0.0'
+end

data/pi_piper.gemspec

@@ -1,35 +1,30 @@
-# -*- encoding: utf-8 -*-
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pi_piper/version'
 
 Gem::Specification.new do |s|
-  s.name = "pi_piper"
-  s.version = "2.0.beta.4"
+  s.name = 'pi_piper'
+  s.version = PiPiper::VERSION
 
-  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Jason Whitehorn"]
-  s.date = "2013-09-14"
-  s.description = "Event driven Raspberry Pi GPIO library"
-  s.email = "jason.whitehorn@gmail.com"
-  s.extra_rdoc_files = ["README.md", "lib/pi_piper.rb", "lib/pi_piper/bcm2835.rb", "lib/pi_piper/frequency.rb", "lib/pi_piper/i2c.rb", "lib/pi_piper/libbcm2835.img", "lib/pi_piper/pin.rb", "lib/pi_piper/platform.rb", "lib/pi_piper/spi.rb"]
-  s.files = ["Gemfile", "Gemfile.lock", "Manifest", "README.md", "Rakefile", "lib/pi_piper.rb", "lib/pi_piper/bcm2835.rb", "lib/pi_piper/frequency.rb", "lib/pi_piper/i2c.rb", "lib/pi_piper/libbcm2835.img", "lib/pi_piper/pin.rb", "lib/pi_piper/platform.rb", "lib/pi_piper/spi.rb", "pi_piper.gemspec"]
-  s.homepage = "http://github.com/jwhitehorn/pi_piper"
-  s.rdoc_options = ["--line-numbers", "--inline-source", "--title", "Pi_piper", "--main", "README.md"]
-  s.require_paths = ["lib"]
-  s.rubyforge_project = "pi_piper"
-  s.rubygems_version = "2.0.0"
-  s.summary = "Event driven Raspberry Pi GPIO library"
+  s.required_rubygems_version = Gem::Requirement.new('>= 2.0.0') if s.respond_to? :required_rubygems_version=
+  s.authors = ['Jason Whitehorn']
+  s.description = 'Event driven Raspberry Pi GPIO library'
+  s.email = 'jason.whitehorn@gmail.com'
+  s.extra_rdoc_files = ['README.md', 'lib/pi_piper/libbcm2835.so']
+  s.files         = `git ls-files -z`.split("\x0")
+  s.homepage = 'http://github.com/jwhitehorn/pi_piper'
+  s.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'Pi_piper', '--main', 'README.md']
+  s.require_paths = ['lib']
+  s.rubygems_version = '2.2.2'
+  s.summary = 'Event driven Raspberry Pi GPIO library'
+  s.licenses = ['BSD']
 
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
+  s.specification_version = 4 if s.respond_to? :specification_version
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<ffi>, [">= 0"])
-      s.add_runtime_dependency(%q<eventmachine>, ["= 1.0.3"])
-    else
-      s.add_dependency(%q<ffi>, [">= 0"])
-      s.add_dependency(%q<eventmachine>, ["= 1.0.3"])
-    end
-  else
-    s.add_dependency(%q<ffi>, [">= 0"])
-    s.add_dependency(%q<eventmachine>, ["= 1.0.3"])
-  end
+  s.add_runtime_dependency 'ffi', '>= 0'
+  s.add_runtime_dependency 'eventmachine', '= 1.0.9'
+  s.add_development_dependency 'rspec', '~> 3.0'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'simplecov'
 end

data/spec/bcm2835_spec.rb

@@ -0,0 +1,132 @@
+require 'spec_helper'
+
+
+describe 'Bcm2835' do
+  
+  before :context do
+    Platform.driver
+  end
+  
+  after :context do
+    Bcm2835.exported_pins.delete_if { true }
+  end
+
+  # describe  'GPIO' do
+    let(:file_like_object) { double("file like object") }
+
+    before :example do
+      allow(File).to receive(:read).and_return("1")
+      allow(File).to receive(:write).and_return("1")
+      allow(File).to receive(:open).and_return(file_like_object)
+    end
+
+    it 'should export a given pin & add it to the list' do
+      expect(File).to receive(:write).with("/sys/class/gpio/export", 4)
+      expect(Bcm2835.exported_pins.include?(4)).not_to be true
+      Bcm2835.export(4)
+      expect(Bcm2835.exported_pins.include?(4)).to be true
+    end
+
+    it 'should unexport a given pin & removed it from the list' do
+      expect(File).to receive(:write).with("/sys/class/gpio/unexport", 4)
+
+      Bcm2835.export(4)
+      expect(Bcm2835.exported_pins.include?(4)).to be true
+      Bcm2835.unexport_pin(4)
+      expect(Bcm2835.exported_pins.include?(4)).not_to be true
+    end
+    
+    it 'should unexport every exported pin' do
+      Bcm2835.export(4)
+      Bcm2835.export(18)
+      Bcm2835.export(27)
+      expect(Bcm2835.exported_pins).to eq [4,18,27]
+      Bcm2835.unexport_all
+      expect(Bcm2835.exported_pins).to eq []
+    end
+
+    it 'should tell if a pin is exported or not' do
+      Bcm2835.export(4)
+      expect(Bcm2835.exported?(4)).to be true
+      expect(Bcm2835.exported?(112)).to be false
+    end
+
+
+    xit 'should unexport every pin at exit of the program' do
+      pending 'Not yet very sure how to test that_exit hook !?'
+      Bcm2835.export(18)
+      Bcm2835.export(4)
+    
+      at_exit {
+        expect(Bcm2835.exported_pins).to eq []
+      }
+    end
+  # end
+
+  # describe 'GPIO' do
+    # before(:all) do
+    #   Bcm2835.export(5)
+    # end
+
+    it 'should set pin\'s direction' do
+      Bcm2835.export(5)
+      expect(File).to receive(:write).with("/sys/class/gpio/gpio5/direction", "in")
+      Bcm2835.pin_direction(5, 'in')
+    end
+    
+    it 'should set pin as an input' do
+      expect(Bcm2835).to receive(:export).with(4)
+      expect(Bcm2835).to receive(:pin_direction).with(4, 'in')
+      Bcm2835.pin_input(4)
+    end
+    
+    it 'should set pin as an  output' do
+      expect(Bcm2835).to receive(:export).with(4)
+      expect(Bcm2835).to receive(:pin_direction).with(4, 'out')
+      Bcm2835.pin_output(4)
+    end
+
+    it 'should set pin value' do
+      Bcm2835.export(5)
+      expect(File).to receive(:write).with("/sys/class/gpio/gpio5/value", 1)
+      Bcm2835.pin_set(5, 1)
+    end
+
+    it 'should get pin value' do
+      Bcm2835.export(5)
+      expect(File).to receive(:read).with("/sys/class/gpio/gpio5/value")
+      Bcm2835.pin_read(5)
+    end
+
+    it 'should stop RW access to pin after unexport' do
+      Bcm2835.unexport_pin(4)
+      expect { Bcm2835.pin_read(4) }.to         raise_error(PinError)
+      expect { Bcm2835.pin_set(4, 1) }.to       raise_error(PinError)
+      expect { Bcm2835.pin_direction(4, 1) }.to raise_error(PinError)
+    end
+
+    it 'should set pin edge' do
+      Bcm2835.export(5)
+      expect(File).to receive(:write).with("/sys/class/gpio/gpio5/edge", :both)
+      Bcm2835.pin_set_edge(5, :both)
+    end
+
+    it 'should wait for an edge event to return' do
+      pending 'how could we test edge trigger ?!'
+      fail
+    end
+
+  # end
+
+  xdescribe 'SPI' do
+    it 'spidev_out(array)'
+    it 'spi_transfer_bytes(data)'
+  end
+  
+  xdescribe 'I2C' do
+    it 'i2c_allowed_clocks'
+    it 'i2c_transfer_bytes(data)'
+    it 'i2c_read_bytes(bytes)'
+  end
+end
+

data/spec/i2c_spec.rb

@@ -0,0 +1,62 @@
+require_relative 'spec_helper'
+
+describe 'I2C' do
+
+  before(:example) do |example|
+    Platform.driver = StubDriver.new
+  end
+  
+  describe 'clock setting' do
+    it 'should check driver settings' do
+      expect(Platform.driver).to receive(:i2c_allowed_clocks).and_return([100.kilohertz])
+      I2C.clock = 100.kilohertz
+    end
+
+    it 'should accept 100 kHz' do
+      expect(Platform.driver).to receive(:i2c_allowed_clocks).and_return([100.kilohertz])
+      expect(Platform.driver).to receive(:i2c_set_clock).with(100.kilohertz)
+      I2C.clock = 100.kilohertz
+    end
+
+    it 'should not accept 200 kHz' do
+      expect(Platform.driver).to receive(:i2c_allowed_clocks).and_return([100.kilohertz])
+      expect { I2C.clock = 200.kilohertz }.to raise_error(RuntimeError)
+    end
+  end
+
+  describe 'when in block' do
+    it 'should call i2c_begin' do
+      expect(Platform.driver).to receive(:i2c_begin)
+      I2C.begin {}
+    end
+
+    it 'should call i2c_end' do
+      expect(Platform.driver).to receive(:i2c_end)
+      I2C.begin {}
+    end
+
+    it 'should call i2c_end even after raise' do
+      expect(Platform.driver).to receive(:i2c_end)
+      begin
+        I2C.begin { raise 'OMG' }
+      rescue
+      end
+    end
+
+    describe 'write operation' do
+      it 'should set address' do
+        expect(Platform.driver).to receive(:i2c_set_address).with(4)
+        I2C.begin do
+          write to: 4, data: [1, 2, 3, 4]
+        end
+      end
+
+      it 'should pass data to driver' do
+        expect(Platform.driver).to receive(:i2c_transfer_bytes).with([1, 2, 3, 4])
+        I2C.begin do
+          write to: 4, data: [1, 2, 3, 4]
+        end
+      end
+    end
+  end
+end

data/spec/pin_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+include PiPiper
+
+describe 'Pin' do
+
+  before(:example) do |example|
+    Platform.driver = StubDriver.new
+  end
+
+  context 'Basic Behaviour' do
+    it 'should export pin for input' do    
+      expect(Platform.driver).to receive(:pin_input).with(4)
+      Pin.new pin: 4, direction: :in
+    end
+
+    it 'should export pin for output' do
+      expect(Platform.driver).to receive(:pin_output).with(4)
+      Pin.new pin: 4, direction: :out
+    end
+
+    it 'should read start value on construction' do
+      expect(Platform.driver).to receive(:pin_read).with(4).and_return(0)
+      Pin.new pin: 4, direction: :in
+    end
+
+    it 'should detect on?' do
+      expect(Platform.driver).to receive(:pin_read).with(4).and_return(1)
+      pin = Pin.new pin: 4, direction: :in
+      expect(pin.on?).to be(true)
+    end
+
+    it 'should detect off?' do
+      expect(Platform.driver).to receive(:pin_read).with(4).and_return(0)
+      pin = Pin.new pin: 4, direction: :in
+      expect(pin.off?).to be(true)
+    end
+
+    it 'should invert true' do
+      expect(Platform.driver).to receive(:pin_read).with(4).and_return(1)
+      pin = Pin.new pin: 4, direction: :in, invert: true
+      expect(pin.on?).to be(false)
+    end
+
+    it 'should invert true' do
+      expect(Platform.driver).to receive(:pin_read).with(4).and_return(0)
+      pin = Pin.new pin: 4, direction: :in, invert: true
+      expect(pin.off?).to be(false)
+    end
+
+    it 'should write high' do
+      expect(Platform.driver).to receive(:pin_set).with(4, 1)
+      pin = Pin.new pin: 4, direction: :out
+      pin.on
+    end
+
+    it 'should write low' do
+      expect(Platform.driver).to receive(:pin_set).with(4, 0)
+      pin = Pin.new pin: 4, direction: :out
+      pin.off
+    end
+
+    it 'should not write high on direction in' do
+      expect(Platform.driver).not_to receive(:pin_set)
+      pin = Pin.new pin: 4, direction: :in
+      pin.on
+    end
+
+    it 'should not write low on direction in' do
+      expect(Platform.driver).not_to receive(:pin_set)
+      pin = Pin.new pin: 4, direction: :in
+      pin.off
+    end
+
+    it 'should detect high to low change' do
+      value = 1
+      # begins low, then high, low, high, low...
+      allow(Platform.driver).to receive(:pin_read) { value ^= 1 }
+
+      pin = Pin.new pin: 4, direction: :in
+      expect(pin.off?).to be(true)
+      pin.read
+      expect(pin.off?).to be(false)
+      expect(pin.changed?).to be(true)
+    end
+
+    it 'should wait for change' do
+      expect(Platform.driver).to receive(:pin_wait_for).with(4, :both)
+      pin = Pin.new pin: 4, direction: :out, edge: :rising
+      pin.wait_for_change
+    end
+  end
+
+  describe 'Pull up/down/float' do
+    let!(:pin_up) do
+      Pin.new(pin: 17, direction: :in, pull: :up)
+    end
+    let!(:pin_down) do
+      Pin.new(pin: 17, direction: :in, pull: :down)
+    end
+    let!(:pin_off) do
+      Pin.new(pin: 17, direction: :in, pull: :off)
+    end
+    let!(:pin_float) do
+      Pin.new(pin: 17, direction: :in, pull: :float)
+    end
+
+    it 'should raise an error for invalid :pull values' do
+      expect { Pin.new(pin: 17, direction: :in, pull: :wth) }.to raise_error PinError
+    end
+
+    it 'should restrict allowed :pull values' do
+      expect(pin_up.pull?).to eq(:up)
+      expect(pin_down.pull?).to eq(:down)
+      expect(pin_off.pull?).to eq(:off)
+      expect(pin_float.pull?).to eq(:off)
+    end
+
+    it 'should not accept pulls when direction is :out' do
+      expect{ Pin.new(pin: 17, direction: :out, pull: :up) }.to raise_error PinError
+      expect{ Pin.new(pin: 17, direction: :out, pull: :down) }.to raise_error PinError
+      expect{ Pin.new(pin: 17, direction: :out, pull: :off) }.not_to raise_error
+    end
+
+    it 'should not allow pull! when direction is :out' do
+      p_out = Pin.new(pin: 17, direction: :out)
+      expect{ p_out.pull!(:up) }.to raise_error PinError
+      expect{ p_out.pull!(:down) }.to raise_error PinError
+      expect{ p_out.pull!(:off) }.not_to raise_error
+    end
+
+    it 'should allow subsequent pull resistor changes when direction is :in' do
+      expect(Platform.driver).to receive(:pin_set_pud).with(17, PinValues::GPIO_PUD_UP)
+      expect(Platform.driver).to receive(:pin_set_pud).with(17, PinValues::GPIO_PUD_DOWN)
+      expect(Platform.driver).to receive(:pin_set_pud).with(17, PinValues::GPIO_PUD_OFF)
+      pin_off.pull!(:up)
+      pin_off.pull!(:down)
+      pin_off.pull!(:off)
+    end
+  end
+end