BBB 0.0.1 → 0.0.2

data/lib/BBB/gpio/base.rb

@@ -0,0 +1,56 @@
+module BBB
+  module GPIO
+    class Base
+      attr_reader :position, :converted_position
+      attr_reader :file_class
+
+      def initialize(position=nil, opts={})
+        initialize_base(position, opts)
+      end
+
+      def initialize_base(pin_position, opts)
+        @mock = opts.fetch(:mock, false)
+        self.position = pin_position
+        @file_class = @mock ? StringIO : File
+	export
+      end
+
+      def position=(position, mock=false)
+        @position = position
+        @converted_position = PinMapper.map(position)
+      end
+
+      def gpio_path
+        "/sys/class/gpio"
+      end
+
+      def export_path
+        gpio_path + "/export"
+      end
+
+      def unexport_path
+        gpio_path + "/unexport"
+      end
+
+      def gpio_direction_input
+        "in"
+      end
+
+      def gpio_direction_output
+        "out"
+      end
+
+      def gpio_pin_dir
+        "#{gpio_path}/gpio#{converted_position}"
+      end
+
+      def export
+        file_class.open(export_path, "w") { |f| f.write("#{ converted_position }") }
+      end
+
+      def unexport
+        file_class.open(unexport_path, "w") { |f| f.write("#{converted_position}") }
+      end
+    end
+  end
+end

data/lib/BBB/gpio/digital_pin.rb

@@ -0,0 +1,69 @@
+module BBB
+  module GPIO
+    class DigitalPin < Base
+      attr_reader :mode, :io
+
+      def initialize(position, mode, opts={})
+        initialize_base(position, opts)
+        @mode = validate_mode(mode)
+        set_mode
+      end
+
+      def direction
+        case mode
+        when :input
+          gpio_direction_input
+        when :output
+          gpio_direction_output
+        end
+      end
+
+      def file_mode
+        case mode
+        when :input
+          "r"
+        when :output
+          "w+"
+        end
+      end
+
+      def set_mode
+        direction_file = gpio_pin_dir + "/direction"
+        file_class.open(direction_file, "w") {|f| f.write(direction); f.flush}
+      end
+
+      def io
+        return @io unless @io.nil?
+
+        value_file     = gpio_pin_dir + "/value"
+        @io = file_class.open(value_file, file_mode)
+      end
+
+      def write(value)
+        io.rewind
+        io.write value_map[value]
+        io.flush
+      end
+
+      def read
+	io.rewind
+        value_map[io.read]
+      end
+
+      private
+
+      def validate_mode(mode)
+        if [:input, :output].include?(mode)
+          return mode
+        else
+          raise UnknownPinModeException, "Pin mode: #{mode} is now known"
+        end
+      end
+
+      def value_map
+        @value_map ||= {:high=>1, :low=>0, 1=>:high, 0=>:low}
+      end
+
+    end
+  end
+end

data/lib/BBB/gpio/pin_converter.rb

@@ -0,0 +1,22 @@
+module BBB
+  module GPIO
+    class PinConverter
+      attr_reader :mock
+
+      def initialize(opts={})
+        @mock = opts.fetch(:mock, false)
+      end
+
+      ##
+      # Currently only converts IO::DigitalPins
+      #
+      def convert(pin, opts={})
+        base_class = pin.class.to_s.split("::").last
+        klass =  GPIO::const_get(base_class.to_sym)
+        opts = {:mock=>mock}.merge(opts)
+        return klass.new(pin.position, pin.mode, opts)
+      end
+
+    end
+  end
+end

data/lib/BBB/io/digital_pin.rb

@@ -0,0 +1,67 @@
+module BBB
+  module IO
+    ##
+    # Credit goes to the great work done at the Artoo framework
+    # The original idea for this class came from them.
+    # https://github.com/hybridgroup/artoo/blob/master/lib/artoo/adaptors/io/digital_pin.rb
+    #
+    class DigitalPin
+      include Pinnable
+      attr_reader :mode, :status
+      attr_accessor :pin_io
+
+      ##
+      # Digital pin which is abstracted away from any kind of IO.
+      # This has the benefit of being able to write a generic application
+      # that you can then easily port to a BBB, Pi or Arduino
+      #
+      # @param pin_num [Symbol]
+      # @param mode [Symbol, nil] the mode of the pin, :input or :output. Defaults
+      # to :input
+      # @pin_io [IO, nil] the IO object
+      #
+      def initialize(mode=:input, pin_io=nil, position=nil)
+        @pin_io = pin_io || MockPin.new
+        @mode = mode
+        @position = position
+      end
+
+      # Writes to the specified pin Digitally
+      # accepts values :high or :low
+      def write(value)
+        raise ArgumentError unless [:high, :low].include?(value)
+        @status = value
+        @pin_io.write(value)
+      end
+
+      # Reads digitally from the specified pin on initialize
+      def read
+	if mode == :input
+	  pin_io.read
+	else
+          status
+	end
+      end
+
+      # Sets digital write for the pin to HIGH
+      def on!
+        write(:high)
+      end
+      #
+      # Sets digital write for the pin to LOW
+      #
+      def off!
+        write(:low)
+      end
+
+      def on?
+        (status == :high) ? true : false
+      end
+
+      def off?
+        !self.on?
+      end
+
+    end
+  end
+end

data/lib/BBB/io/mock_pin.rb

@@ -0,0 +1,8 @@
+require 'stringio'
+
+module BBB
+  module IO
+    class MockPin < StringIO
+    end
+  end
+end

data/lib/BBB/io/pinnable.rb

@@ -0,0 +1,12 @@
+module BBB
+  module IO
+    module Pinnable
+      attr_reader :position
+
+      def position=(position)
+        @position = position
+      end
+    end
+  end
+end
+

data/lib/BBB/pin_mapper.rb

@@ -0,0 +1,84 @@
+module BBB
+  class PinMapper
+    ##
+    # Thanks to artoo-beaglebone
+    # https://github.com/hybridgroup/artoo-beaglebone/blob/master/lib/artoo/adaptors/beaglebone.rb
+    #
+    PINS = {
+        :P8_3 => 38,
+        :P8_4 => 39,
+        :P8_5 => 34,
+        :P8_6 => 35,
+        :P8_7 => 66,
+        :P8_8 => 67,
+        :P8_9 => 69,
+        :P8_10 => 68,
+        :P8_11 => 45,
+        :P8_12 => 44,
+        :P8_13 => 23,
+        :P8_14 => 26,
+        :P8_15 => 47,
+        :P8_16 => 46,
+        :P8_17 => 27,
+        :P8_18 => 65,
+        :P8_19 => 22,
+        :P8_20 => 63,
+        :P8_21 => 62,
+        :P8_22 => 37,
+        :P8_23 => 36,
+        :P8_24 => 33,
+        :P8_25 => 32,
+        :P8_26 => 61,
+        :P8_27 => 86,
+        :P8_28 => 88,
+        :P8_29 => 87,
+        :P8_30 => 89,
+        :P8_31 => 10,
+        :P8_32 => 11,
+        :P8_33 => 9,
+        :P8_34 => 81,
+        :P8_35 => 8,
+        :P8_36 => 80,
+        :P8_37 => 78,
+        :P8_38 => 79,
+        :P8_39 => 76,
+        :P8_40 => 77,
+        :P8_41 => 74,
+        :P8_42 => 75,
+        :P8_43 => 72,
+        :P8_44 => 73,
+        :P8_45 => 70,
+        :P8_46 => 71,
+        :P9_11 => 30,
+        :P9_12 => 60,
+        :P9_13 => 31,
+        :P9_14 => 50,
+        :P9_15 => 48,
+        :P9_16 => 51,
+        :P9_17 => 5,
+        :P9_18 => 4,
+        :P9_19 => 13,
+        :P9_20 => 12,
+        :P9_21 => 3,
+        :P9_22 => 2,
+        :P9_23 => 49,
+        :P9_24 => 15,
+        :P9_25 => 117,
+        :P9_26 => 14,
+        :P9_27 => 115,
+        :P9_28 => 113,
+        :P9_29 => 111,
+        :P9_30 => 112,
+        :P9_31 => 110
+      }
+      attr_reader :pins
+
+    def self.map(pin_symbol)
+      begin
+        PINS.fetch(pin_symbol.upcase.to_sym)
+      rescue Exception => e
+        raise UnknownPinException, "Pin #{pin_symbol} could not be mapped"
+      end
+    end
+  end
+end

data/lib/BBB/test_board.rb

@@ -0,0 +1,11 @@
+module BBB
+  class TestBoard < BBB::Board
+
+    private
+
+    def self.pin_converter
+      GPIO::PinConverter.new(mock:true)
+    end
+  end
+end
+

data/lib/BBB/version.rb

@@ -1,3 +1,3 @@
 module BBB
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/spec/application_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe BBB::Application do
+
+  it "initializes" do
+    lambda { BBB::Application.new }.should_not raise_exception
+  end
+
+  class MockCircuit
+    def components; {}; end
+  end
+
+  class TestBoardApp < BBB::Application
+    board "board"
+    circuit MockCircuit.new
+  end
+
+  it "defaults board to class variable board" do
+    TestBoardApp.instance_variable_get('@_board').should eql("board")
+  end
+
+  it "sets the board as an instance variable" do
+    app = TestBoardApp.new
+    app.board.should eql("board")
+  end
+
+  it "sets a circuit" do
+    app = TestBoardApp.new
+    app.circuit.class.should eql(MockCircuit)
+  end
+
+  class TestLedCircuit < BBB::Circuit
+    def initialize
+      attach BBB::Components::Led, pin: :P8_3, as: :led
+    end
+  end
+
+  class TestConnectionApp < BBB::Application
+    board BBB::TestBoard.new
+    circuit TestLedCircuit.new
+  end
+
+  it "attaches virtual pins to board pins" do
+    app = TestConnectionApp.new
+
+    app.circuit.respond_to?(:led).should be_true
+    app.circuit.led.should_receive(:on!)
+    app.led.should eql(app.circuit.led)
+
+    app.led.on!
+  end
+
+end

data/spec/board_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe BBB::Board do
+  let(:bbb) {BBB::TestBoard.new}
+
+  it "initializes with a converter" do
+    BBB::Board.should_not_receive(:pin_converter)
+    converter = "SomeConverter"
+    board = BBB::Board.new(converter)
+    board.pin_converter.should eql(converter)
+  end
+
+  it "initializes with a default configuration" do
+    BBB::Board.should_receive(:pin_converter) { 'Default Config' }
+    board = BBB::Board.new
+  end
+
+  context "setting pins" do
+    Pin = BBB::IO::DigitalPin
+
+    it "defines input function for input pin" do
+      pin = Pin.new(:input, nil, :P8_3)
+      bbb.setup_pin(pin)
+      bbb.respond_to?("p8_3").should be_true
+    end
+
+    it "defines output function for input pin" do
+      pin = Pin.new(:output, nil, :P8_3)
+      bbb.setup_pin(pin)
+      bbb.respond_to?("p8_3=").should be_true
+    end
+
+    it "enables output function for output pin" do
+      pin = Pin.new(:output, nil, :P8_3)
+      bbb.setup_pin(pin)
+      bbb.p8_3=:low
+      pin.status.should eql(:low)
+    end
+
+    it "should keep the reference to the pin" do
+      pin = Pin.new(:output, nil, :P8_4)
+      bbb.connect_io_pin(pin)
+      pin.write :high
+      bbb.p8_4.should eql(:high)
+    end
+
+  end
+
+end