pi_piper 1.3.2 → 1.9.9

data/examples/simple_switch/simple_switch.rb

@@ -0,0 +1,10 @@
+require 'pi_piper'
+
+puts "Press the switch to get started"
+
+PiPiper.watch :pin => 17, :invert => true do |pin|
+  puts "Pin changed from #{pin.last_value} to #{pin.value}"
+end
+
+PiPiper.wait
+

data/lib/pi_piper.rb

@@ -1,8 +1,5 @@
-Dir[File.dirname(__FILE__) + '/pi_piper/*.rb'].each {|file| require file }
-at_exit do 
-  PiPiper::Bcm2835.close
-end 
-PiPiper::Bcm2835.init
+require 'eventmachine'
+Dir[File.dirname(__FILE__) + '/pi_piper/*.rb'].each {|file| require file unless file.end_with?('bcm2835.rb') }
 
 module PiPiper
   extend self
@@ -38,8 +35,44 @@ module PiPiper
     options[:trigger] = options.delete(:goes) == :high ? :rising : :falling
     watch options, &block
   end
+  
+  #Defines an event block to be called on a regular schedule. The block will be passed the slave output.
+  #
+  # @param [Hash] options A hash of options.
+  # @option options [Fixnum] :every A frequency of time (in seconds) to poll the SPI slave.
+  # @option options [Fixnum] :slave The slave number to poll.
+  # @option options [Number|Array] :write Data to poll the SPI slave with. 
+  def poll_spi(options, &block)
+    EM::PeriodicTimer.new(options[:every]) do
+      Spi.begin options[:slave] do
+        output = write options[:write]
+        block.call output
+      end
+    end
+  end
+  
+  #Defines an event block to be called when SPI slave output meets certain characteristics. 
+  #The block will be passed the slave output.
+  #
+  # @param [Hash] options A hash of options.
+  # @option options [Fixnum] :every A frequency of time (in seconds) to poll the SPI slave.
+  # @option options [Fixnum] :slave The slave number to poll.
+  # @option options [Number|Array] :write Data to poll the SPI slave with. 
+  # @option options [Fixnum] :eq Tests for SPI slave output equality.
+  # @option options [Fixnum] :lt Tests for SPI slave output less than supplied value.
+  # @option options [Fixnum] :gt Tests for SPI slave output greater than supplied value.
+  def when_spi(options, &block)
+    poll_spi options do |value|
+      if (options[:eq] && value == options[:eq]) || 
+         (options[:lt] && value < options[:lt])  ||
+         (options[:gt] && value > options[:gt])
+          block.call value
+      end
+    end
+  end
 
   #Prevents the main thread from exiting. Required when using PiPiper.watch
+  # @deprecated Please use EventMachine.run instead
   def wait
     loop do sleep 1 end
   end

data/lib/pi_piper/bcm2835.rb

@@ -2,19 +2,73 @@ require 'ffi'
 
 module PiPiper
   # The Bcm2835 module is not intended to be directly called.
-  # It serves as an FFI library for PiPiper::SPI.
+  # It serves as an FFI library for PiPiper::SPI & PiPiper::I2C.
   module Bcm2835
     extend FFI::Library
-    ffi_lib File.dirname(__FILE__) + '/libbcm2835.img'
+    ffi_lib File.dirname(__FILE__) + '/libbcm2835.so'
+    @pins = []
 
     SPI_MODE0 = 0
     SPI_MODE1 = 1
     SPI_MODE2 = 2
     SPI_MODE3 = 3
 
+    I2C_REASON_OK         = 0  #Success
+    I2C_REASON_ERROR_NACK = 1  #Received a NACK
+    I2C_REASON_ERROR_CLKT = 2  #Received Clock Stretch Timeout
+    I2C_REASON_ERROR_DATA = 3  #Not all data is sent / received
+
     attach_function :init, :bcm2835_init, [], :uint8
     attach_function :close, :bcm2835_close, [], :uint8
 
+    #pin support...
+    attach_function :pin_set_pud, :bcm2835_gpio_set_pud, [:uint8, :uint8], :void
+    
+    def self.pin_input(pin)
+      export(pin)
+      pin_direction(pin, 'in')
+    end
+
+    def self.pin_set(pin, value)
+      File.open("/sys/class/gpio/gpio#{pin}/value", 'w') {|f| f.write("#{value}") }
+    end
+
+    def self.pin_output(pin)
+      export(pin)
+      pin_direction(pin, 'out')
+    end
+
+    def self.pin_read(pin)
+      File.read("/sys/class/gpio/gpio#{pin}/value").to_i
+    end
+
+    def self.pin_direction(pin, direction)
+      File.open("/sys/class/gpio/gpio#{pin}/direction", 'w') do |f|
+        f.write(direction)
+      end
+    end
+
+    # Exports pin and subsequently locks it from outside access
+    def self.export(pin)
+      File.open('/sys/class/gpio/export', 'w') { |f| f.write("#{pin}") }
+      @pins << pin unless @pins.include?(pin)
+    end
+
+    def self.release_pin(pin)
+      File.open('/sys/class/gpio/unexport', 'w') { |f| f.write("#{pin}") }
+      @pins.delete(pin)
+    end
+
+    def self.release_pins
+      @pins.dup.each { |pin| release_pin(pin) }
+    end
+
+    #NOTE to use: chmod 666 /dev/spidev0.0
+    def self.spidev_out(array)
+      File.open('/dev/spidev0.0', 'wb'){|f| f.write(array.pack('C*')) }
+    end
+
+    #SPI support...
     attach_function :spi_begin,       :bcm2835_spi_begin,            [], :uint8
     attach_function :spi_end,         :bcm2835_spi_end,              [], :uint8
     attach_function :spi_transfer,    :bcm2835_spi_transfer,         [:uint8], :uint8
@@ -26,8 +80,23 @@ module PiPiper
     attach_function :spi_chip_select_polarity, 
                     :bcm2835_spi_setChipSelectPolarity,              [:uint8, :uint8], :void
 
+    #I2C support...
+    attach_function :i2c_begin,      :bcm2835_i2c_begin,             [], :void
+    attach_function :i2c_end,        :bcm2835_i2c_end,               [], :void
+    attach_function :i2c_write,      :bcm2835_i2c_write,             [:pointer, :uint], :uint8
+    attach_function :i2c_set_address,:bcm2835_i2c_setSlaveAddress,   [:uint8], :void
+    attach_function :i2c_set_clock_divider, :bcm2835_i2c_setClockDivider,     [:uint16], :void
+    attach_function :i2c_read,       :bcm2835_i2c_read,              [:pointer, :uint], :uint8
+
+    def self.i2c_allowed_clocks
+      [100.kilohertz,
+       399.3610.kilohertz,
+       1.666.megahertz,
+       1.689.megahertz]
+    end
+
     def self.spi_transfer_bytes(data)
-      data_out = FFI::MemoryPointer.new(data.count) 
+      data_out = FFI::MemoryPointer.new(data.count)
       data_in = FFI::MemoryPointer.new(data.count)
       (0..data.count-1).each { |i| data_out.put_uint8(i, data[i]) }
 
@@ -36,5 +105,18 @@ module PiPiper
       (0..data.count-1).map { |i| data_in.get_uint8(i) }
     end
 
+    def self.i2c_transfer_bytes(data)
+      data_out = FFI::MemoryPointer.new(data.count)
+      (0..data.count-1).each{ |i| data_out.put_uint8(i, data[i]) } 
+
+      i2c_write data_out, data.count
+    end
+
+    def self.i2c_read_bytes(bytes)
+      data_in = FFI::MemoryPointer.new(bytes)
+      i2c_read(data_in, bytes) #TODO reason codes 
+
+      (0..bytes-1).map { |i| data_in.get_uint8(i) } 
+    end
   end
 end

data/lib/pi_piper/frequency.rb

@@ -0,0 +1,19 @@
+module Frequency 
+
+  def kilohertz
+    self * 1000
+  end
+
+  def megahertz
+    self * 1000000
+  end
+
+end
+
+class Float
+  include Frequency
+end
+
+class Integer
+  include Frequency
+end

data/lib/pi_piper/i2c.rb

@@ -0,0 +1,51 @@
+module PiPiper
+
+  #I2C support
+  class I2C
+
+#http://www.airspayce.com/mikem/bcm2835/group__i2c.html
+
+    def initialize
+      Platform.driver.i2c_begin
+    end
+
+    def end
+      Platform.driver.i2c_end
+    end
+
+    def self.begin(&block)
+      instance = I2C.new
+      begin
+        if block.arity > 0
+          block.call instance
+        else
+          instance.instance_exec &block 
+        end
+      ensure
+        instance.end
+      end
+    end
+
+    def self.clock=(clock)
+      valid_clocks = Platform.driver.i2c_allowed_clocks
+      raise "Invalid clock rate. Valid clocks are 100 kHz, 399.3610 kHz, 1.666 MHz and 1.689 MHz" unless valid_clocks.include? clock
+
+      Platform.driver.i2c_set_clock clock
+    end
+
+    def write(params)
+      data = params[:data]
+      address = params[:to]
+
+      raise ":data must be enumerable" unless data.class.include? Enumerable
+      Platform.driver.i2c_set_address address
+      Platform.driver.i2c_transfer_bytes data
+    end
+
+    def read(bytes)
+      Platform.driver.i2c_read_bytes(bytes)
+    end
+
+  end
+
+end

data/lib/pi_piper/pin.rb

@@ -1,70 +1,148 @@
+require_relative 'pin_values'
+
 module PiPiper
   # Represents a GPIO pin on the Raspberry Pi
   class Pin
-    attr_reader :pin, :last_value, :value, :direction, :invert
-    
+    include PiPiper::PinValues
+
+    attr_reader :pin, :last_value, :direction, :invert
+
     #Initializes a new GPIO pin.
     #
     # @param [Hash] options A hash of options
     # @option options [Fixnum] :pin The pin number to initialize. Required.
-    # @option options [Symbol] :direction The direction of communication, either :in or :out. Defaults to :in.
-    # @option options [Boolean] :invert Indicates if the value read from the physical pin should be inverted. Defaults to false.
-    # @option options [Symbol] :trigger Indicates when the wait_for_change method will detect a change, either :rising, :falling, or :both edge triggers. Defaults to :both.
+    # 
+    # @option options [Symbol] :direction The direction of communication, 
+    # either :in or :out. Defaults to :in.
+    # 
+    # @option options [Boolean] :invert Indicates if the value read from the 
+    # physical pin should be inverted. Defaults to false.
+    # 
+    # @option options [Symbol] :trigger Indicates when the wait_for_change 
+    # method will detect a change, either :rising, :falling, or :both edge 
+    # triggers. Defaults to :both.
+    # 
+    # @option options [Symbol] :pull Indicates if and how pull mode must be 
+    # set when pin direction is set to :in. Either :up, :down or :offing. 
+    # Defaults to :off.
+    #
     def initialize(options)
-      options = {:direction => :in, :invert => false, :trigger => :both}.merge options
-      @pin = options[:pin]
+      options = { :direction => :in,
+                  :invert => false,
+                  :trigger => :both,
+                  :pull => :off}.merge(options)
+
+      @pin       = options[:pin]
       @direction = options[:direction]
-      @invert = options[:invert]
-      @trigger = options[:trigger]
-      
-      raise "Invalid direction. Options are :in or :out" unless [:in, :out].include? @direction
-      raise "Invalid trigger. Options are :rising, :falling, or :both" unless [:rising, :falling, :both].include? @trigger
-     
-      File.open("/sys/class/gpio/export", "w") { |f| f.write("#{@pin}") }
-      File.open(direction_file, "w") { |f| f.write(@direction == :out ? "out" : "in") }
-      
-      read 
-    end
-    
-    # If the pin has been initialized for output this method will set the logic level high.
+      @invert    = options[:invert]
+      @trigger   = options[:trigger]
+      @pull      = options[:pull]
+      @released  = false
+
+      raise "Invalid pull mode. Options are :up, :down or :float (default)" unless 
+        [:up, :down, :float, :off].include? @pull
+      raise "Unable to use pull-ups : pin direction must be ':in' for this" if 
+        @direction != :in and [:up, :down].include?(@pull)
+      raise "Invalid direction. Options are :in or :out" unless 
+        [:in, :out].include? @direction
+      raise "Invalid trigger. Options are :rising, :falling, or :both" unless 
+        [:rising, :falling, :both].include? @trigger
+
+      if @direction == :out
+        Platform.driver.pin_output(@pin)
+      else
+        Platform.driver.pin_input(@pin)
+      end
+      pull!(@pull)
+
+      read
+    end
+
+    # If the pin has been initialized for output this method will set the 
+    # logic level high.
     def on
-      File.open(value_file, 'w') {|f| f.write("1") } if direction == :out
+      fail PiPiper::PinError, "Pin #{@pin} already released" if released?
+      Platform.driver.pin_set(pin, GPIO_HIGH) if direction == :out
     end
-    
+
     # Tests if the logic level is high.
     def on?
       not off?
     end
-    
-    # If the pin has been initialized for output this method will set the logic level low.
+
+    # If the pin has been initialized for output this method will set 
+    # the logic level low.
     def off
-      File.open(value_file, 'w') {|f| f.write("0") } if direction == :out
+      fail PiPiper::PinError, "Pin #{@pin} already released" if released?
+      Platform.driver.pin_set(pin, GPIO_LOW) if direction == :out
     end
-    
+
     # Tests if the logic level is low.
     def off?
-      value == 0
+      value == GPIO_LOW
     end
 
-    # If the pin has been initialized for output this method will either raise or lower the logic level depending on `new_value`.
+    def value
+      @value ||= read
+    end
+
+    # If the pin has been initialized for output this method will either raise 
+    # or lower the logic level depending on `new_value`.
     # @param [Object] new_value If false or 0 the pin will be set to off, otherwise on.
     def update_value(new_value)
-      !new_value || new_value == 0 ? off : on
+      !new_value || new_value == GPIO_LOW ? off : on
+    end
+    alias_method :value=, :update_value
+
+    # When the pin has been initialized in input mode, internal resistors can 
+    # be pulled up or down (respectively with :up and :down).
+    # 
+    # Pulling an input pin will prevent noise from triggering it when the input
+    # is floating.
+    # 
+    # For instance when nothing is plugged in, pulling the pin-up will make 
+    # subsequent value readings to return 'on' (or high, or 1...).
+    # @param [Symbol] state Indicates if and how pull mode must be set when 
+    # pin direction is set to :in. Either :up, :down or :offing. Defaults to :off.
+    def pull!(state)
+      return nil if @direction != :in
+      fail PiPiper::PinError, "Pin #{@pin} already released" if released?
+      @pull = case state
+              when :up then GPIO_PUD_UP
+              when :down then GPIO_PUD_DOWN
+              # :float and :off are just aliases
+              when :float, :off then GPIO_PUD_OFF
+              else nil
+              end
+
+      Platform.driver.pin_set_pud(@pin, @pull) if @pull
+      @pull
+    end
+
+    # If the pin direction is input, it will return the current state of 
+    # pull-up/pull-down resistor, either :up, :down or :off.
+    def pull?
+      case @pull
+      when GPIO_PUD_UP then :up
+      when GPIO_PUD_DOWN then :down
+      else :off
+      end
     end
-    
+
     # Tests if the logic level has changed since the pin was last read.
     def changed?
       last_value != value
     end
 
-    # blocks until a logic level change occurs. The initializer option `:trigger` modifies what edge this method will release on.
+    # Blocks until a logic level change occurs. The initializer option 
+    # `:trigger` modifies what edge this method will release on.
     def wait_for_change
       fd = File.open(value_file, "r")
       File.open(edge_file, "w") { |f| f.write("both") }
       loop do
         fd.read
         IO.select(nil, nil, [fd], nil)
-        read 
+        read
         if changed?
           next if @trigger == :rising and value == 0
           next if @trigger == :falling and value == 1
@@ -73,15 +151,29 @@ module PiPiper
       end
     end
 
-    # Reads the current value from the pin. Without calling this method first, `value`, `last_value` and `changed?` will not be updated. 
-    # In short, you must call this method if you are curious about the current state of the pin.
-    def read 
+    # Reads the current value from the pin. Without calling this method 
+    # first, `value`, `last_value` and `changed?` will not be updated.
+    # 
+    # In short, you must call this method if you are curious about the 
+    # current state of the pin.
+    def read
+      fail PiPiper::PinError, "Pin #{@pin} already released" if released?
       @last_value = @value
-      val = File.read(value_file).to_i
+      val = Platform.driver.pin_read(@pin)
       @value = invert ? (val ^ 1) : val
     end
-    
+
+    def release
+      Platform.driver.release_pin(@pin)
+      @released = true
+    end
+
+    def released?
+      @released == true
+    end
+
     private
+
     def value_file
       "/sys/class/gpio/gpio#{pin}/value"
     end
@@ -93,6 +185,5 @@ module PiPiper
     def direction_file
       "/sys/class/gpio/gpio#{pin}/direction"
     end
-  
   end
 end