pi_piper 2.0.beta.4 → 2.0.0

data/examples/elro/elro.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/ruby
+$LOAD_PATH << File.join(File.dirname(__FILE__), 'lib')
+
+require 'pi_piper'
+require 'elro_switch'
+
+exit(0) unless ARGV[0]
+
+device = ARGV[0].to_i
+switch_on = ARGV[1]
+key = [0,0,0,0,1]
+
+pin = PiPiper::Pin.new(:pin => 17, :direction => :out)
+elro = ElroSwitch.new(device, key, pin)
+elro.switch(switch_on == "1")

data/examples/elro/lib/elro_switch.rb

@@ -0,0 +1,51 @@
+require 'elro_util'
+
+# ElroSwitch is a little tool written to send trigger-events from a RaspberryPi 
+# to an Elro remote controlled switch.
+#
+# It works perfectly with PiPiper: https://github.com/jwhitehorn/pi_piper
+#
+# See README.md for more information.
+#
+# == CREDITS
+# Written by Torsten Mangner (https://github.com/alphaone).
+# This library is mostly a (heavily refactored) port from this python script 
+#   http://pastebin.com/aRipYrZ6
+# by Heiko H.,
+# which is a port from a C++ snippet
+#   http://www.jer00n.nl/433send.cpp
+# written by J. Lukas,
+# and influenced by this Arduino source code
+#   http://gathering.tweakers.net/forum/view_message/34919677
+# written by Piepersnijder.
+class ElroSwitch
+  include ElroUtil
+
+  # devices: according to dipswitches on your Elro receivers
+  #          or 
+  #          a numeric A = 1, B = 2, C = 4, D = 8, E = 16
+  # key:     according to dipswitches on your Elro receivers
+  # pin:     an object that responses to #update_value(bool) (like PiPiper::Pin)
+  def initialize(device, key, pin)
+    raise ArgumentError.new("key has to be of size 5") unless key.size == 5
+    raise ArgumentError.new("device has to be Numeric or Array") unless (device.is_a?(Numeric) or device.is_a?(Array))
+    raise ArgumentError.new("device has to be of size 5") if (device.is_a?(Array) and device.size != 5)
+    raise ArgumentError.new("device has to be between 0 and 31") if (device.is_a?(Numeric) and !((0..31) === device))
+    raise ArgumentError.new("pin has no method :update_value") unless pin.respond_to?(:update_value)
+    @key = key
+    @device = device
+    @pin = pin
+  end
+
+  def switch(switch)
+    sequence = []
+    sequence << ElroUtil.sequence_for_key(@key)
+    sequence << ElroUtil.sequence_for_device(@device)
+    sequence << ElroUtil.sequence_for_onoff(switch)
+    sequence << ElroUtil.sequence_for_static_part
+
+    pulses = ElroUtil.pulses_from_sequence(sequence.flatten)
+    ElroUtil.send_pulses(@pin, pulses)
+  end
+
+end

data/examples/elro/lib/elro_util.rb

@@ -0,0 +1,64 @@
+# ElroUtil will do the hard work for ElroSwitch
+#
+# == WARNING
+# The Raspberry is not build to be the fastest hardware in the world.
+# Ruby (MRI) is not fastest programming language (but still the best).
+# The Elro Switch expects the 1280 signals for each switch-event to be 
+# transmitted with a frequency of 300 microseconds (but as I have observed
+# will still operate while using frequencies from ≈100 to ≈600 microseconds
+# per signal).
+#
+# This implementation (using PiPiper) reaches a frequency of around 
+# 500 microseconds on an RaspberryPi without any wait or sleep.
+#
+# Other implementation (in python or C) need to time their signals to
+# not be too fast.
+#
+# Keep that in mind, if this code will run on faster hardware or faster Rubies.
+module ElroUtil
+
+  DIP_OFF = 142
+  DIP_ON  = 136
+  REPEAT = 10 # Number of transmissions
+
+  def ElroUtil.sequence_for_key(key)
+    key.map { |dip| (dip == 1) ? DIP_ON : DIP_OFF }
+  end
+
+  def ElroUtil.sequence_for_device(device)
+    if device.is_a?(Array)
+      device.map { |dip| dip == 1 ? DIP_ON : DIP_OFF }
+    elsif device.is_a?(Numeric)
+      ElroUtil.convert_to_bits(device, 5).reverse.map { |b| b ? DIP_ON : DIP_OFF }
+    end
+  end
+
+  def ElroUtil.sequence_for_onoff(switch_on)
+    switch_on ? [DIP_ON, DIP_OFF] : [DIP_OFF, DIP_ON]
+  end
+
+  def ElroUtil.sequence_for_static_part
+    [128, 0, 0, 0]
+  end
+
+  def ElroUtil.pulses_from_sequence(sequence)
+    sequence.map { |part| ElroUtil.convert_to_bits(part, 8) }.flatten
+  end
+
+  def ElroUtil.send_pulses(pin, pulses, verbose=false)
+    pin.update_value(false)
+    start_time = Time.now
+    REPEAT.times do
+      pulses.each { |b| pin.update_value(b) }
+    end
+    end_time = Time.now
+    if verbose
+      puts "avg %.0f microsecs per pulse" % ((end_time - start_time) / (10 * 16 * 8) * 1_000_000)
+    end
+  end
+
+  def ElroUtil.convert_to_bits(num, length)
+    sprintf("%0#{length}d", num.to_s(2)).split("").map {|b| b.to_i & 1 == 1}
+  end
+
+end

data/examples/elro/spec/elro_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe ElroSwitch do
+
+  let(:pin) {double("pi_piper_pin", :update_value => nil)}
+
+  it "does not allow wrong key length" do
+    expect {ElroSwitch.new(1, [0,0,1,0,1,0], pin)}.to raise_error ArgumentError
+  end
+
+  it "does expect a Numeric or a List as device" do
+    expect {ElroSwitch.new([0,0,0,0,0], [0,1,0,1,0], pin)}.not_to raise_error ArgumentError
+    expect {ElroSwitch.new(15, [0,1,0,1,0], pin)}.not_to raise_error ArgumentError
+    expect {ElroSwitch.new("x", [0,1,0,1,0], pin)}.to raise_error ArgumentError
+  end
+
+  it "does expect a numeric device to be between 0 and 31" do
+    expect {ElroSwitch.new(-1, [0,1,0,1,0], pin)}.to raise_error ArgumentError
+    expect {ElroSwitch.new( 0, [0,1,0,1,0], pin)}.not_to raise_error ArgumentError
+    expect {ElroSwitch.new(31, [0,1,0,1,0], pin)}.not_to raise_error ArgumentError
+    expect {ElroSwitch.new(32, [0,1,0,1,0], pin)}.to raise_error ArgumentError
+  end
+
+  it "does not allow wrong device length" do
+    expect {ElroSwitch.new([0,0,0,0], [0,1,0,1,0], pin)}.to raise_error ArgumentError
+  end
+
+  it "sends pulses on switch" do
+    pin.should_receive(:update_value).exactly(16 * 8 * 10 + 1).times
+
+    elro = ElroSwitch.new(1, [0,0,1,0,1], pin)
+    elro.switch(true)
+  end
+
+end

data/examples/elro/spec/elro_util_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe ElroUtil do
+
+  it "generates correct sequence for key" do
+    ElroUtil.sequence_for_key([0,0,1,0,1]).should == 
+      [142, 142, 136, 142, 136]
+  end
+
+  it "generates correct sequence for device" do
+    ElroUtil.sequence_for_device(7).should == 
+      [136, 136, 136, 142, 142]
+  end
+
+  it "generates correct sequence for device as array" do
+    ElroUtil.sequence_for_device([1,1,1,0,0]).should == 
+      [136, 136, 136, 142, 142]
+  end
+
+  it "generates correct sequence for on/off" do
+    ElroUtil.sequence_for_onoff(true).should == 
+      [136, 142]
+    ElroUtil.sequence_for_onoff(false).should == 
+      [142, 136]
+  end
+
+  it "generates correct sequence for static part" do
+    ElroUtil.sequence_for_static_part.should == 
+      [128, 0, 0, 0]
+  end
+
+  it "converts numbers to bits" do
+    ElroUtil.convert_to_bits(7, 8).should == [false, false, false, false, false, true, true, true]
+  end
+
+  it "converts sequence to bit pulses" do
+    ElroUtil.pulses_from_sequence([136, 142]).should == 
+      [
+        true, false, false, false, true, false, false, false,
+        true, false, false, false, true, true,  true,  false
+      ]
+  end
+
+  it "sends pulses" do
+    pin = double("pi_piper_pin")
+    pin.should_receive(:update_value).exactly(40 + 1).times
+
+    ElroUtil.send_pulses(pin, [true, false, false, true])
+  end
+
+end

data/examples/elro/spec/spec_helper.rb

@@ -0,0 +1,6 @@
+require 'rspec'
+require File.join(File.dirname(__FILE__), '..', 'lib', 'elro_switch')
+
+RSpec.configure do |config|
+  # ...
+end

data/examples/mcp3008/mcp3008.rb

@@ -0,0 +1,55 @@
+require 'pi_piper'
+#port of the Adafruit MCP3008 interface code found @ http://learn.adafruit.com/send-raspberry-pi-data-to-cosm/python-script
+
+def read_adc(adc_pin, clockpin, adc_in, adc_out, cspin)
+  cspin.on
+  clockpin.off
+  cspin.off
+  
+  command_out = adc_pin
+  command_out |= 0x18
+  command_out <<= 3
+
+  (0..4).each do
+    adc_in.update_value((command_out & 0x80) > 0)
+    command_out <<= 1
+    clockpin.on
+    clockpin.off
+  end
+  result = 0
+
+  (0..11).each do
+    clockpin.on
+    clockpin.off
+    result <<= 1
+    adc_out.read
+    if adc_out.on?
+      result |= 0x1
+    end
+  end 
+
+  cspin.on
+
+  result >> 1
+end
+  
+clock = PiPiper::Pin.new :pin => 18, :direction => :out
+adc_out = PiPiper::Pin.new :pin => 23
+adc_in = PiPiper::Pin.new :pin => 24, :direction => :out
+cs = PiPiper::Pin.new :pin => 25, :direction => :out
+
+adc_pin = 0
+
+loop do
+  value = read_adc(adc_pin, clock, adc_in, adc_out, cs)
+  invert = 1023 - value
+  mvolts = invert * (3300.0 / 1023.0)
+  if mvolts < 2700
+    temp = (mvolts - 380.0) / (2320.0 / 84.0)
+  else
+    temp = (mvolts - 2700.0) / (390.0 / 92.0) + 84.0
+  end
+  temp_f = (temp * 9.0 / 5.0) + 32
+  puts "Value = #{value}, invert = #{invert}, mvolts = #{mvolts}, temp = #{temp} C | #{temp_f} F"
+  sleep 1
+end

data/examples/mcp3008_spi/mcp3008_spi.rb

@@ -0,0 +1,24 @@
+require 'pi_piper'
+#special thanks to Jeremy Blythe, and his article @ http://jeremyblythe.blogspot.com/2012/09/raspberry-pi-hardware-spi-analog-inputs.html
+#it greatly helped in getting the MCP3008 setup with SPI
+
+adc_num = 0 
+
+loop do
+  value = 0
+  PiPiper::Spi.begin do |spi|
+    raw = spi.write [1, (8+adc_num)<<4, 0] 
+    value = ((raw[1]&3) << 8) + raw[2]
+  end
+
+  invert = 1023 - value
+  mvolts = invert * (3300.0 / 1023.0)
+  if mvolts < 2700
+    temp = (mvolts - 380.0) / (2320.0 / 84.0)
+  else
+    temp = (mvolts - 2700.0) / (390.0 / 92.0) + 84.0
+  end
+  temp_f = (temp * 9.0 / 5.0) + 32
+  puts "Value = #{value}, invert = #{invert}, mvolts = #{mvolts}, temp = #{temp} C | #{temp_f} F"
+  sleep 1
+end

data/examples/morse_code/morse_code.rb

@@ -0,0 +1,49 @@
+require 'pi_piper'
+
+unit = 0.1
+dot = unit
+dash = unit * 3
+inter_element_gap = unit
+short_gap = unit * 3
+medium_gap = unit * 7
+
+#http://en.wikipedia.org/wiki/Morse_code
+character_timing = { "a" => [dot, dash],             "b" => [dash, dot, dot, dot],   "c" => [dash, dot, dash, dot],
+                     "d" => [dash, dot, dot],        "e" => [dot],                   "f" => [dot, dot, dash, dot], 
+                     "g" => [dash, dash, dot],       "h" => [dot, dot, dot, dot],    "i" => [dot, dot],
+                     "j" => [dot, dash, dash, dash], "k" => [dash, dot, dash],       "l" => [dot, dash, dot, dot],
+                     "m" => [dash, dash],            "n" => [dash, dot],             "o" => [dash, dash, dash],
+                     "p" => [dot, dash, dash, dot],  "q" => [dash, dash, dot, dash], "r" => [dot, dash, dot],
+                     "s" => [dot, dot, dot],         "t" => [dash],                  "u" => [dot, dot, dash],
+                     "v" => [dot, dot, dot, dash],   "w" => [dot, dash, dash],       "x" => [dash, dot, dot, dash],
+                     "y" => [dash, dot, dash, dash], "z" => [dash, dash, dot, dot],
+                     "0" => [dash, dash, dash, dash, dash],  "1" => [dot, dash, dash, dash, dash],
+                     "2" => [dot, dot, dash, dash, dash],    "3" => [dot, dot, dot, dash, dash],
+                     "4" => [dot, dot, dot, dot, dash],      "5" => [dot, dot, dot, dot, dot],
+                     "6" => [dash, dot, dot, dot, dot],      "7" => [dash, dash, dot, dot, dot],
+                     "8" => [dash, dash, dash, dot, dot],    "9" => [dash, dash, dash, dash, dot]
+                   } 
+
+pin = PiPiper::Pin.new(:pin => 17, :direction => :out)
+pin.off
+
+loop do
+  puts "Please type something"
+  something = gets.chomp.downcase
+
+  something.each_char do |letter|
+    if letter == " "
+      pin.off
+      sleep medium_gap
+    else
+      character_timing[letter].each do |timing| 
+        pin.on
+        sleep timing
+        pin.off
+        sleep inter_element_gap
+      end
+      sleep short_gap - inter_element_gap
+    end
+  end
+
+end

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,5 +1,5 @@
 require 'eventmachine'
-Dir[File.dirname(__FILE__) + '/pi_piper/*.rb'].each {|file| require file }#unless file.end_with?('bcm2835.rb') }
+Dir[File.dirname(__FILE__) + '/pi_piper/*.rb'].each {|file| require file unless file.end_with?('bcm2835.rb') }
 
 module PiPiper
   extend self
@@ -11,7 +11,7 @@ module PiPiper
   #   Options hash. Options include `:pin`, `:invert` and `:trigger`.
   # 
   def watch(options, &block)
-    Thread.new do
+    new_thread = Thread.new do
       pin = PiPiper::Pin.new(options)
       loop do
         pin.wait_for_change 
@@ -21,7 +21,9 @@ module PiPiper
           pin.instance_exec &block
         end
       end 
-    end.abort_on_exception = true  
+    end
+    new_thread.abort_on_exception = true
+    new_thread
   end
   
   #Defines an event block to be executed after a pin either goes high or low.

data/lib/pi_piper/bcm2835.rb

@@ -5,7 +5,8 @@ module PiPiper
   # 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
@@ -20,27 +21,97 @@ module PiPiper
     attach_function :init, :bcm2835_init, [], :uint8
     attach_function :close, :bcm2835_close, [], :uint8
     
+    # Sets the Function Select register for the given pin, which configures the pin as Input, Output or one of the 6 alternate functions.
+    attach_function :gpio_select_function, :bcm2835_gpio_fsel,    [:uint8, :uint8], :void
+    # attach_function :gpio_set,             :bcm2835_gpio_set,     [:uint8], :void
+    # attach_function :gpio_clear,           :bcm2835_gpio_clr,     [:uint8], :void
+    # attach_function :gpio_level,           :bcm2835_gpio_lev,     [:uint8], :uint8
+
     #pin support...
-    attach_function :pin_set_pud,         :bcm2835_gpio_set_pud,     [:uint8, :uint8], :void
+    attach_function :pin_set_pud, :bcm2835_gpio_set_pud, [:uint8, :uint8], :void
     
     def self.pin_input(pin)
-      File.open("/sys/class/gpio/export", "w") { |f| f.write("#{pin}") }
-      File.open("/sys/class/gpio/gpio#{pin}/direction", "w") { |f| f.write("in") }
+      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}") }
+      raise PiPiper::PinError, "Pin #{pin} not exported" unless exported?(pin)
+      File.write("/sys/class/gpio/gpio#{pin}/value", value)
     end
-    
-    def Bcm2835.pin_output(pin)
-      File.open("/sys/class/gpio/export", "w") { |f| f.write("#{pin}") }
-      File.open("/sys/class/gpio/gpio#{pin}/direction", "w") { |f| f.write("out") }
+
+    def self.pin_output(pin)
+      export(pin)
+      pin_direction(pin, 'out')
     end
-    
+
     def self.pin_read(pin)
+      raise PiPiper::PinError, "Pin #{pin} not exported" unless exported?(pin)
       File.read("/sys/class/gpio/gpio#{pin}/value").to_i
     end
 
+    #PWM support...
+    attach_function :pwm_clock,     :bcm2835_pwm_set_clock,  [:uint32], :void
+    attach_function :pwm_mode,      :bcm2835_pwm_set_mode,   [:uint8, :uint8, :uint8], :void
+    attach_function :pwm_range,     :bcm2835_pwm_set_range,  [:uint8, :uint32], :void
+    attach_function :pwm_data,      :bcm2835_pwm_set_data,   [:uint8, :uint32], :void
+
+    def self.pin_direction(pin, direction)
+      raise PiPiper::PinError, "Pin #{pin} not exported" unless exported?(pin)
+      File.write("/sys/class/gpio/gpio#{pin}/direction", direction)
+    end
+
+    def self.export(pin)
+      File.write('/sys/class/gpio/export', pin)
+      @pins << pin unless @pins.include?(pin)
+    end
+
+    def self.unexport_pin(pin)
+      File.write('/sys/class/gpio/unexport', pin)
+      @pins.delete(pin)
+    end
+
+    def self.unexport_all
+      @pins.dup.each { |pin| unexport_pin(pin) }
+    end
+
+    def self.exported_pins
+      @pins
+    end
+
+    def self.exported?(pin)
+      @pins.include?(pin)
+    end
+
+    # Support "none", "rising", "falling", or "both"
+    def self.pin_set_edge(pin, trigger)
+      raise PiPiper::PinError, "Pin #{pin} not exported" unless exported?(pin)
+      File.write("/sys/class/gpio/gpio#{pin}/edge", trigger)
+    end
+
+    def self.pin_wait_for(pin, trigger)
+      pin_set_edge(pin, trigger)
+
+      fd = File.open("/sys/class/gpio/gpio#{pin}/value", "r")
+      value = nil
+      loop do
+        fd.read
+        IO.select(nil, nil, [fd], nil)
+        last_value = value
+        value = self.pin_read(pin)
+        if last_value != value
+          next if trigger == :rising and value == 0
+          next if trigger == :falling and value == 1
+          break
+        end
+      end
+    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
@@ -65,11 +136,11 @@ module PiPiper
       [100.kilohertz,
        399.3610.kilohertz,
        1.666.megahertz,
-       1.689.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]) }
 
@@ -91,6 +162,5 @@ module PiPiper
 
       (0..bytes-1).map { |i| data_in.get_uint8(i) } 
     end
-
   end
 end