BBB 0.0.10 → 0.1.0

data/lib/BBB/pins/io/pwm.rb

@@ -0,0 +1,61 @@
+module BBB
+  module Pins
+    module IO
+      class PWM
+        include Mapped
+
+        attr_reader :handles, :position
+
+        def initialize(position)
+          @position = position
+          self.export
+          @handles = get_file_handles
+        end
+
+        def path
+          return @path unless @path.nil?
+          @path = Dir.glob("/sys/devices/ocp.*/pwm_test_#{pin_map.key}.*").first
+        end
+
+        def get_file_handles
+          handles = {}
+          files = %w(duty period polarity run)
+
+          files.each do |file|
+            file_path = File.expand_path(file, path)
+            handles[file.to_sym] = File.open(file_path, "r+")
+          end
+
+          return handles
+        end
+
+        def export
+          cape_dir = "/sys/devices/bone_capemgr.*/slots"
+          dir = Dir.glob(cape_dir)
+          if dir.length == 0
+            raise BoardError, "unable to access the capemgr directory: #{cape_dir}"
+          end
+
+          pin_map_key = pin_map.key # This calls the pin map, which raises an error in case pin can't be mapped.
+          system("echo am33xx_pwm > #{dir.first}")
+          system("echo bone_pwm_#{pin_map_key} > #{dir.first}")
+        end
+
+        def write(symbol, value)
+          handle = handles[symbol]
+          handle.rewind
+          handle.write(value)
+          handle.flush
+          return value
+        end
+
+        def read(symbol)
+          handle = handles[symbol]
+          handle.rewind
+          handle.read.to_i
+        end
+      end
+    end
+  end
+end
+

data/lib/BBB/pins/pinnable.rb

@@ -0,0 +1,78 @@
+module BBB
+  module Pins
+    ##
+    # Module which is included in all pins. The module provides the basic
+    # interface for a BBB::Pin and also takes care of selecting the right IO
+    # class to work with.
+    #
+    # It defines a #pinnable? method to test if the module is properly included
+    # in a pin.
+    #
+    module Pinnable
+      attr_reader :position, :opts
+
+      ##
+      # Initializes a Pin
+      #
+      # @param position [Symbol] The position of the pin
+      # @option opts [Boolean] :mock whether or not to use MockIO
+      #
+      def initialize(position, opts={})
+        @position     = position
+        @opts         = opts
+      end
+
+      ##
+      # Returns an instance of the IO class for the pin and memoizes this.
+      #
+      # @return [IO]
+      #
+      def io
+        @io ||= mock? ? mock_io : default_io
+      end
+
+      ##
+      # Return wheter or not this is a mock pin
+      #
+      # @return [Boolean]
+      #
+      def mock?
+        @mock ||= @opts.fetch(:mock, false)
+      end
+
+      ##
+      # Always returns true, method is used to test if module is included.
+      #
+      # @return [Boolean] true
+      #
+      def pinnable?
+        true
+      end
+
+      private
+
+      ##
+      # If a class includes the Pinnable module, it should overwrite the
+      # default_io method. If this is not done, the module raises an error to
+      # point the developer into the right direction.
+      #
+      # The default_io method should return an instantiated object that makes
+      # the inteface between the filesystem, drivers etc, and the ruby code.
+      # Probably the object will behave like an IO object, relying on the linux
+      # kernel and drivers to get things done on the board.
+      #
+      def default_io
+        raise NotImplementedError
+      end
+
+      ##
+      # The IO instance used for mock pins. By default this is StringIO.new,
+      # however, each class should determine if it defines its own MockIO class.
+      # An example of which can be found at the PWMPin.
+      #
+      def mock_io
+        StringIO.new
+      end
+    end
+  end
+end

data/lib/BBB/pins/pwm_pin.rb

@@ -0,0 +1,43 @@
+module BBB
+  module Pins
+    class PWMPin
+      include Pinnable
+
+      %w(duty polarity period run).each do |method|
+        define_method("#{method}=".to_sym) do |value|
+          io.write(method.to_sym, value.to_i)
+        end
+
+        define_method(method.to_sym) do
+          io.read(method.to_sym)
+        end
+      end
+
+      def period_hz(herz)
+        self.period = 1/herz*10e9
+      end
+
+      private
+
+      def default_io
+        IO::PWM.new(position)
+      end
+
+      class MockIO < StringIO
+        def write(symbol, value)
+          super(value)
+        end
+
+        def read(symbol)
+          rewind
+          super().to_i
+        end
+      end
+
+      def mock_io
+        MockIO.new
+      end
+
+    end
+  end
+end

data/lib/BBB/version.rb

@@ -1,3 +1,3 @@
 module BBB
-  VERSION = "0.0.10"
+  VERSION = "0.1.0"
 end

data/spec/application_spec.rb

@@ -6,29 +6,6 @@ describe BBB::Application 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
@@ -36,7 +13,6 @@ describe BBB::Application do
   end
 
   class TestConnectionApp < BBB::Application
-    board   BBB::Board::TestBoard.new
     circuit TestLedCircuit.new
 
     def run
@@ -49,13 +25,12 @@ describe BBB::Application do
 
     app.circuit.respond_to?(:led).should be_true
     app.circuit.led.should_receive(:on!)
-    app.led.should eql(app.circuit.led)
 
+    app.led.should eql(app.circuit.led)
     app.led.on!
   end
 
   class FunctionsInApp < BBB::Application
-    board   BBB::Board::TestBoard.new
     circuit TestLedCircuit.new
 
     def run

data/spec/circuit_spec.rb

@@ -1,7 +1,6 @@
 require "spec_helper"
 
 describe BBB::Circuit do
-  let(:circuit) {BBB::Circuit.new}
   let(:c) { BBB::Circuit.new }
   # You can't really avoid some integration testing here
   let(:led) { BBB::Components::Led }

data/spec/components/analog_component_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe BBB::Components::AnalogComponent do
+  let(:component) { BBB::Components::AnalogComponent.new }
+  let(:component_class) { BBB::Components::AnalogComponent }
+
+  it "includes Pinnable module" do
+    component.pinnable?.should be_true
+  end
+
+  it "registers AnalogPin" do
+    component_class.pins.should eql([BBB::Pins::AnalogPin])
+  end
+
+  context "initialized" do
+    before :each do
+      @c = component
+      @c.initialize_pins(:P8_13)
+    end
+
+    it "#pin" do
+      @c.pin.class.should eql(BBB::Pins::AnalogPin)
+    end
+
+    it "#read" do
+      @c.pin.should_receive(:read)
+      @c.read
+    end
+
+    it "#value aliasses #read" do
+      @c.should_receive(:read)
+      @c.value
+    end
+  end
+
+end

data/spec/components/led_spec.rb

@@ -3,42 +3,37 @@ require 'spec_helper'
 describe BBB::Components::Led do
   let(:led) {BBB::Components::Led.new}
 
+  before :each do
+    led.initialize_pins(:P8_4, mock: true)
+  end
+
   it "initializes off" do
-    led.off?.should be_true
+    led.off?
   end
 
   it "set state: on" do
+    led.pin.should_receive(:on!)
     led.on!
-    led.on?.should be_true
   end
 
   it "set state: off" do
-    led.on!
+    led.pin.should_receive(:off!)
     led.off!
-    led.off?.should be_true
   end
 
   it "check state: on?" do
-    led.off!
-    led.on!
-    led.on?.should be_true
+    led.pin.should_receive(:on?)
+    led.on?
   end
 
-  it "provides access to state "do
-    led.on!
-    led.state.should eql(:high)
-    led.off!
-    led.state.should eql(:low)
+  it "check state: on?" do
+    led.pin.should_receive(:off?)
+    led.off?
   end
 
   context "#pinnable include" do
-    it "responds to pinnable actions" do
-      led.respond_to?(:register_pin_positions)
-    end
-
-    it "sets the right pin position" do
-      led.register_pin_positions(:P8_3)
-      led.pin.position.should eql(:P8_3)
+    it "responds to pinnable?" do
+      led.pinnable?.should be_true
     end
   end
 

data/spec/components/pinnable_spec.rb

@@ -1,19 +1,84 @@
 require 'spec_helper'
 
 describe BBB::Components::Pinnable do
+  class DummyPin
+    include BBB::Pins::Pinnable
+  end
+
   class DummyComponent
     include BBB::Components::Pinnable
+    uses DummyPin
+  end
+
+  class DoubleDummyComponent
+    include BBB::Components::Pinnable
+    uses DummyPin, DummyPin
+  end
+
+  let(:dummy) { DummyComponent }
+  let(:double_dummy) { DoubleDummyComponent }
+
+  context "#initialize_pins" do
+    it "with single position" do
+      DummyPin.should_receive(:new).once.and_return(@mock_pin)
+      c = dummy.new
+      c.initialize_pins(:P8_3)
+      c.pins[0].should eql(@mock_pin)
+    end
+
+    it "with single position and options" do
+      DummyPin.should_receive(:new).with(:P8_3, {:key=>"value"}).once
+        .and_return(@mock_pin)
+      c = dummy.new
+      c.initialize_pins(:P8_3, key: "value")
+      c.pins[0].should eql(@mock_pin)
+    end
+
+    it "with multiple positions" do
+      DummyPin.should_receive(:new).exactly(2).times.and_return(@mock_pin)
+      c = double_dummy.new
+      c.initialize_pins(:P8_3, :P8_4)
+      c.pins[0].should eql(@mock_pin)
+      c.pins[1].should eql(@mock_pin)
+    end
+
+    it "with multiple positions and options" do
+      DummyPin.should_receive(:new).with(:P8_3, {:key=>"value"}).once
+        .and_return(@mock_pin)
+      DummyPin.should_receive(:new).with(:P8_4, {:key=>"value"}).once
+        .and_return(@mock_pin)
+      c = double_dummy.new
+      c.initialize_pins(:P8_3, :P8_4, key: "value")
+      c.pins[0].should eql(@mock_pin)
+      c.pins[1].should eql(@mock_pin)
+    end
+
+    it "verifies the pin count" do
+      c = dummy.new
+      c.should_receive(:verify_pin_position_count).with([:P8_3])
+      c.initialize_pins(:P8_3)
+    end
+  end
+
+  context "#verify_pin_position_count" do
+
+    it "raises exception when counts don't match" do
+      c = dummy.new
+      lambda do
+        c.verify_pin_position_count([:foo, :bar])
+      end.should raise_exception(BBB::PinsDoNotMatchException)
+    end
 
-    def initialize
-      pin = Struct.new(:position)
-      @pins = [pin.new(0), pin.new(1)]
+    it "does not raise an exception when counts do match" do
+      c = dummy.new
+      lambda do
+        c.verify_pin_position_count([:foo])
+      end.should_not raise_exception
     end
   end
 
-  it "knows how to register pins" do
-    comp = DummyComponent.new
-    comp.register_pin_positions(:P8_3, :P8_4)
-    comp.pins[0].position.should eql(:P8_3)
-    comp.pins[1].position.should eql(:P8_4)
+  it "should respond to pinnable?" do
+    c = dummy.new
+    c.pinnable?.should be_true
   end
 end

data/spec/components/servo_spec.rb

@@ -0,0 +1,6 @@
+require 'spec_helper'
+
+describe BBB::Components::Servo do
+  let(:servo) { BBB::Components::Servo.new }
+
+end