pi_piper 1.3.2 → 1.9.9

data/lib/pi_piper/pin_error.rb

@@ -0,0 +1,3 @@
+module PiPiper
+  class PinError < StandardError; end
+end

data/lib/pi_piper/pin_values.rb

@@ -0,0 +1,10 @@
+module PiPiper
+  module PinValues
+    GPIO_PUD_OFF = 0
+    GPIO_PUD_DOWN = 1
+    GPIO_PUD_UP = 2
+
+    GPIO_HIGH = 1
+    GPIO_LOW  = 0
+  end
+end

data/lib/pi_piper/platform.rb

@@ -0,0 +1,25 @@
+module PiPiper
+
+  #Hardware abstraction manager. Not intended for direct use.
+  class Platform
+    @@driver = nil
+
+    #gets the current platform driver. Defaults to BCM2835.
+    def self.driver
+      unless @@driver
+        require 'pi_piper/bcm2835'
+        PiPiper::Bcm2835.init
+        @@driver = PiPiper::Bcm2835
+        at_exit do
+          Bcm2835.release_pins
+          Bcm2835.close
+        end
+      end
+      @@driver
+    end
+
+    def self.driver=(instance)
+      @@driver = instance
+    end
+  end
+end

data/lib/pi_piper/spi.rb

@@ -28,39 +28,9 @@
 #++
 
 
-
-
-
 module PiPiper
   # class for SPI interfaces on the Raspberry Pi
   class Spi
-    # 65536 = 256us = 4kHz
-    CLOCK_DIVIDER_65536 = 0
-    # 32768 = 126us = 8kHz
-    CLOCK_DIVIDER_32768 = 32768
-    # 16384 = 64us = 15.625kHz
-    CLOCK_DIVIDER_16384 = 16384
-    # 8192 = 32us = 31.25kHz
-    CLOCK_DIVIDER_8192  = 8192
-    # 4096 = 16us = 62.5kHz
-    CLOCK_DIVIDER_4096  = 4096
-    # 2048 = 8us = 125kHz
-    CLOCK_DIVIDER_2048  = 2048
-    # 1024 = 4us = 250kHz
-    CLOCK_DIVIDER_1024  = 1024
-    # 512 = 2us = 500kHz
-    CLOCK_DIVIDER_512   = 512
-    # 256 = 1us = 1MHz
-    CLOCK_DIVIDER_256   = 256
-    # 128 = 500ns = = 2MHz
-    CLOCK_DIVIDER_128   = 128
-    # 64 = 250ns = 4MHz
-    CLOCK_DIVIDER_64    = 64
-    # 32 = 125ns = 8MHz
-    CLOCK_DIVIDER_32    = 32
-    # 16 = 50ns = 20MHz
-    CLOCK_DIVIDER_16    = 16
-
     # Least signifigant bit first, e.g. 4 = 0b001
     LSBFIRST = 0
     # Most signifigant bit first, e.g. 4 = 0b100
@@ -75,18 +45,24 @@ module PiPiper
     # No CS, control it yourself
     CHIP_SELECT_NONE = 3
 
+    # SPI Modes
+    SPI_MODE0 = 0
+    SPI_MODE1 = 1
+    SPI_MODE2 = 2
+    SPI_MODE3 = 3 
+
     #Sets the SPI mode. Defaults to mode (0,0).
     def self.set_mode(cpol, cpha)
       mode = SPI_MODE0 #default
       mode = SPI_MODE1 if cpol == 0 and cpha == 1
       mode = SPI_MODE2 if cpol == 1 and cpha == 0
       mode = SPI_MODE3 if cpol == 1 and cpha == 1
-      Bcma2835.spi_set_data_mode mode
+      Platform.driver.spi_set_data_mode mode
     end
 
     #Begin an SPI block. All SPI communications should be wrapped in a block.
     def self.begin(chip=nil, &block)
-      Bcm2835.spi_begin
+      Platform.driver.spi_begin
       chip = CHIP_SELECT_0 if !chip && block_given?
       spi = new(chip)
 
@@ -99,11 +75,39 @@ module PiPiper
 
     # Not needed when #begin is called with a block
     def self.end
-      Bcm2835.spi_end
+      Platform.driver.spi_end
     end
 
-    def clock(divider)
-      Bcm2835.spi_clock(divider)
+    # Uses /dev/spidev0.0 to write to the SPI
+    # NOTE: Requires that you have /dev/spidev0.0
+    #  see: http://learn.adafruit.com/adafruit-raspberry-pi-educational-linux-distro/overview
+    #  most likely requires `chmod 666 /dev/spidev0.0`
+    #
+    # @example Writing red, green, blue to a string of WS2801 pixels
+    #   PiPiper::Spi.spidev_out([255,0,0,0,255,0,0,0,255])
+    #
+    def self.spidev_out(array)
+      Platform.driver.spidev_out(array)
+    end
+
+    # Sets the SPI clock frequency
+    def clock(frequency)
+      options = {4000     => 0,      #4 kHz
+                 8000     => 32768,  #8 kHz
+                 15625    => 16384,  #15.625 kHz
+                 31250    => 8192,   #31.25 kHz
+                 62500    => 4096,   #62.5 kHz
+                 125000   => 2048,   #125 kHz
+                 250000   => 1024,   #250 kHz
+                 500000   => 512,    #500 kHz
+                 1000000  => 256,    #1 MHz
+                 2000000  => 128,    #2 MHz
+                 4000000  => 64,     #4 MHz
+                 8000000  => 32,     #8 MHz
+                 20000000 => 16      #20 MHz
+               }
+      divider = options[frequency]
+      Platform.driver.spi_clock(divider)
     end
 
     def bit_order(order=MSBFIRST)
@@ -115,7 +119,7 @@ module PiPiper
         end
       end
 
-      Bcm2835.spi_bit_order(order)
+      Platform.driver.spi_bit_order(order)
     end
 
     # Activate a specific chip so that communication can begin
@@ -137,13 +141,13 @@ module PiPiper
     # @yield 
     # @param [optional, CHIP_SELECT_*] chip the chip select line options
     def chip_select(chip=CHIP_SELECT_0)
-      chip = @chip if @chip 
-      Bcm2835.spi_chip_select(chip) 
+      chip = @chip if @chip
+      Platform.driver.spi_chip_select(chip) 
       if block_given?
         begin
           yield
         ensure
-          Bcm2835.spi_chip_select(CHIP_SELECT_NONE)
+          Platform.driver.spi_chip_select(CHIP_SELECT_NONE)
         end
       end
     end
@@ -162,7 +166,7 @@ module PiPiper
       chip = @chip if @chip
       chip = CHIP_SELECT_0 unless chip
 
-      Bcm2835.spi_chip_select_polarity(chip, active_low ? 0 : 1)
+      Platform.driver.spi_chip_select_polarity(chip, active_low ? 0 : 1)
     end
 
     # Read from the bus
@@ -182,7 +186,7 @@ module PiPiper
       if count
         write([0xFF] * count)
       else
-        enable { Bcm2835.spi_transfer(0) }
+        enable { Platform.driver.spi_transfer(0) }
       end
     end
 
@@ -208,9 +212,9 @@ module PiPiper
       enable do
         case data
         when Numeric
-          Bcm2835.spi_transfer(data)
+          Platform.driver.spi_transfer(data)
         when Enumerable
-          Bcm2835.spi_transfer_bytes(data)
+          Platform.driver.spi_transfer_bytes(data)
         else
           raise ArgumentError.new("#{data.class} is not valid data. Use Numeric or an Enumerable of numbers")
         end

data/lib/pi_piper/stub_driver.rb

@@ -0,0 +1,107 @@
+# @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 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 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/pi_piper.gemspec

@@ -1,16 +1,20 @@
-# -*- 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 = "1.3.2"
+  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-04"
+  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/libbcm2835.img", "lib/pi_piper/pin.rb", "lib/pi_piper/spi.rb"]
-  s.files = ["Manifest", "README.md", "Rakefile", "lib/pi_piper.rb", "lib/pi_piper/bcm2835.rb", "lib/pi_piper/libbcm2835.img", "lib/pi_piper/pin.rb", "lib/pi_piper/spi.rb", "pi_piper.gemspec"]
+  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.so", "lib/pi_piper/pin.rb", "lib/pi_piper/platform.rb", "lib/pi_piper/spi.rb"]
+  s.files         = `git ls-files -z`.split("\x0")
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
   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"]
@@ -18,15 +22,22 @@ Gem::Specification.new do |s|
   s.rubygems_version = "2.0.0"
   s.summary = "Event driven Raspberry Pi GPIO library"
 
-  if s.respond_to? :specification_version then
+  if s.respond_to? :specification_version
     s.specification_version = 4
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0')
       s.add_runtime_dependency(%q<ffi>, [">= 0"])
+      s.add_runtime_dependency(%q<eventmachine>, ["= 1.0.9"])
     else
       s.add_dependency(%q<ffi>, [">= 0"])
+      s.add_dependency(%q<eventmachine>, ["= 1.0.9"])
     end
   else
     s.add_dependency(%q<ffi>, [">= 0"])
+    s.add_dependency(%q<eventmachine>, ["= 1.0.9"])
   end
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'mocha'
+  s.add_development_dependency 'simplecov'
 end

data/spec/i2c_spec.rb

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

data/spec/pin_spec.rb

@@ -0,0 +1,149 @@
+require 'spec_helper'
+include PiPiper
+
+describe 'Pin' do
+  it 'should export pin for input' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_input).with(4)
+    end
+    Pin.new pin: 4, direction: :in
+  end
+
+  it 'should export pin for output' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_output).with(4)
+    end
+
+    Pin.new pin: 4, direction: :out
+  end
+
+  it 'should read start value on construction' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_read).with(4).and_return(0)
+    end
+
+    Pin.new pin: 4, direction: :in
+  end
+
+  it 'should detect on?' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_read).with(4).and_return(1)
+    end
+
+    pin = Pin.new pin: 4, direction: :in
+    expect(pin.on?).to be(true)
+  end
+
+  it 'should detect off?' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_read).with(4).and_return(0)
+    end
+
+    pin = Pin.new pin: 4, direction: :in
+    expect(pin.off?).to be(true)
+  end
+
+  it 'should invert true' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_read).with(4).and_return(1)
+    end
+
+    pin = Pin.new pin: 4, direction: :in, invert: true
+    expect(pin.on?).to be(false)
+  end
+
+  it 'should invert true' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_read).with(4).and_return(0)
+    end
+
+    pin = Pin.new pin: 4, direction: :in, invert: true
+    expect(pin.off?).to be(false)
+  end
+
+  it 'should write high' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_set).with(4, 1)
+    end
+
+    pin = Pin.new pin: 4, direction: :out
+    pin.on
+  end
+
+  it 'should write low' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).to receive(:pin_set).with(4, 0)
+    end
+
+    pin = Pin.new pin: 4, direction: :out
+    pin.off
+  end
+
+  it 'should not write high on direction in' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).not_to receive(:pin_set)
+    end
+
+    pin = Pin.new pin: 4, direction: :in
+    pin.on
+  end
+
+  it 'should not write low on direction in' do
+    Platform.driver = StubDriver.new.tap do |d|
+      expect(d).not_to receive(:pin_set)
+    end
+
+    pin = Pin.new pin: 4, direction: :in
+    pin.off
+  end
+
+  it 'should detect high to low change' do
+    Platform.driver = StubDriver.new.tap do |d|
+      value = 1
+      # begins low, then high, low, high, low...
+      allow(d).to receive(:pin_read) { value ^= 1 }
+    end
+
+    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
+
+  xit 'should wait for change' do
+    pending
+  end
+
+  context 'given a pin is released' do
+    it 'should actually release it' do
+      Platform.driver = StubDriver.new.tap do |driver|
+        expect(driver).to receive(:release_pin).with(4)
+      end
+   
+      pin = Pin.new(pin: 4, direction: :in)
+      pin.release
+      expect(pin.released?).to be(true)
+    end
+
+    it 'should not mark unreleased pins as released' do
+      pin = Pin.new(pin: 4, direction: :in)
+      expect(pin.released?).to be(false)
+    end
+
+    it 'should not continue to use the pin' do
+      Platform.driver = StubDriver.new.tap do |driver|
+        expect(driver).to receive(:release_pin).with(4)
+      end
+
+      pin = Pin.new(pin: 4, direction: :in)
+      pin.release
+
+      expect { pin.read }.to raise_error(PinError, 'Pin 4 already released')
+      expect { pin.on }.to raise_error(PinError, 'Pin 4 already released')
+      expect { pin.off }.to raise_error(PinError, 'Pin 4 already released')
+      expect { pin.pull!(:up) }.to(
+        raise_error(PinError, 'Pin 4 already released'))
+    end
+  end
+end