pi_piper 1.9.9 → 2.0.beta.1

data/examples/dsl_switch/dsl_switch.rb

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

data/examples/mcp3008/mcp3008.rb

@@ -1,55 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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]} 
-
-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

@@ -1,10 +0,0 @@
-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/pin_error.rb

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

data/lib/pi_piper/pin_values.rb

@@ -1,10 +0,0 @@
-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/stub_driver.rb

@@ -1,107 +0,0 @@
-# @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/spec/i2c_spec.rb

@@ -1,83 +0,0 @@
-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

@@ -1,149 +0,0 @@
-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