BBB 0.0.10 → 0.1.0

data/lib/BBB.rb

@@ -1,30 +1,26 @@
-require "BBB/version"
-
 require "json"
+require "stringio"
 
-require "BBB/board/base"
-require "BBB/board/test_board"
-require "BBB/board/json_pin_mapper"
-require "BBB/board/pin_mapper"
+require "BBB/version"
 
 require "BBB/circuit"
 require "BBB/exceptions"
 
-require "BBB/gpio/base"
-require "BBB/gpio/digital_pin"
-require "BBB/gpio/pin_converter"
+require "BBB/pins/io/pin_mapper"
+require "BBB/pins/io/mapped"
+require "BBB/pins/io/ain"
+require "BBB/pins/io/gpio"
+require "BBB/pins/io/pwm"
 
-require "BBB/adc/setup"
-require "BBB/adc/analog_pin"
-
-require "BBB/io/pinnable"
-require "BBB/io/digital_pin"
-require "BBB/io/analog_pin"
-require "BBB/io/mock_pin"
+require "BBB/pins/pinnable"
+require "BBB/pins/digital_pin"
+require "BBB/pins/analog_pin"
+require "BBB/pins/pwm_pin"
 
 require "BBB/components/pinnable"
-require "BBB/components/led"
 require "BBB/components/analog_component"
+require "BBB/components/led"
+require "BBB/components/servo"
 
 require "BBB/application"
 

data/lib/BBB/application.rb

@@ -1,42 +1,25 @@
 module BBB
   class Application
 
-    def self.board(board)
-      @_board = board
-      connect unless @_circuit.nil?
-    end
-
     def self.circuit(circuit)
       @_circuit = circuit
-      connect unless @_board.nil?
-    end
-
-    def self._board
-      @_board
+      define_convenience_methods(circuit)
     end
 
     def self._circuit
       @_circuit
     end
 
-    def self.connect
-      @_circuit.components.each_pair do |name, component|
-        component.pins.each do |pin|
-          @_board.connect_io_pin(pin)
-        end
-
+    def self.define_convenience_methods(c)
+      c.components.keys.each do |name|
         define_method(name) do
           circuit.send(name)
         end
       end
     end
 
-    def board
-      @board ||= self.class._board
-    end
-
     def circuit
-      @circuit ||= self.class._circuit
+      self.class._circuit
     end
 
     def start

data/lib/BBB/circuit.rb

@@ -1,56 +1,49 @@
 module BBB
   ##
-  # The idea here is to attach a piece of equipment to a circuit. The circuit
-  # will later be connected to a board.
+  # The idea here is to attach a piece of equipment to a circuit.
   #
   # A component (e.g. Led or Servo) will define generic pins, like
-  # DigitalInput or AnalogOutput. And then, when the circuit gets attached to
-  # the board those pins will be "connected" to their "physical" counterparts
-  # on the board.
-  #
-  # This allows you to develop generic circuits that can be attached to any
-  # board. At least, in theory :-)
+  # DigitalInput or AnalogOutput. And then, when the component gets attached to
+  # the circuit those pins will be initialized using the file system.
   #
   # For now the attachment will be made onto specific pin numbers. For the BBB
   # this might for example be :P8_3, however, the plan is to, in a future
   # release, make sure that there are converters between the different kind of
   # boards. For example by mapping P8_3 on BBB to P1 on an Arduino.
   #
-  # As of now, the act of "attaching" something onto the circuit equals
-  # setting up a component with generic pins.
-  #
   class Circuit
-    attr_reader :components
+    attr_reader :components, :mock
 
     def components
       @components ||= {}
     end
 
+    def mock?
+      @mock == true
+    end
+
     ##
     # Attach a component of a certain type to the circuit
     #
     # @param component [Class] The class of the object you # want to attach.
     # @param opts [Hash] Hash of options that setup the component
     #
+    # @option opts [Symbol] :pin The pin position for the component
     # @option opts [Array<Symbol>] :pins The list of pin numbers used on the
-    # circuit.
+    #     circuit.
+    # @options opts [Symbol] :as The name of the component
     #
     def attach(component, opts={})
-      if component.kind_of?(Class)
-        component = component.new
-      end
+      name          = opts.delete(:as)
+      component     = component.new if component.kind_of?(Class)
+      pin_positions = opts.delete(:pins) || [opts.delete(:pin)]
+      pin_options   = {:mock=>self.mock?}.merge!(opts)
 
-      if pin_positions = opts[:pins] || [opts[:pin]]
-        component_pins = component.pins
-        verify_pin_argument_count(component_pins.count, pin_positions.count)
-        component.register_pin_positions(pin_positions)
-      end
-
-      name = opts.fetch(:as)
-      register_component(component, name)
+      component.initialize_pins(pin_positions, pin_options)
+      define_method_for_component(component, name)
     end
 
-    def register_component(component, name)
+    def define_method_for_component(component, name)
       components[name] = component
       eigenclass = class << self; self; end
       eigenclass.class_eval do
@@ -60,13 +53,5 @@ module BBB
       end
     end
 
-    def verify_pin_argument_count(type_count, position_count)
-      if type_count != position_count
-        raise PinsDoNotMatchException,
-          "#{object.to_s} requires #{types_count} but received #{position_count} pin arguments."
-      end
-    end
-
-
   end
 end

data/lib/BBB/components/analog_component.rb

@@ -1,22 +1,45 @@
 module BBB
   module Components
+    ##
+    # An AnalogComponent is a component that reads from an analog input (AIN) on
+    # the board. You can use a generic analog component for, for example,
+    # temperature or light sensors.
+    #
+    # The BeagleBoneBlack has 12 bit (4096) AIN pins. So the expected value of
+    # an analog pin is between 0 and 4096.
+    #
     class AnalogComponent
       include Pinnable
 
-      attr_reader :pin, :pins
-
-      def initialize
-        @pin = BBB::IO::AnalogPin.new
-        @pins = [@pin]
-      end
+      uses BBB::Pins::AnalogPin
 
+      ##
+      # Read from an initialized pin, if the pins have not been initialized yet,
+      # this method might actually raise an exception.
+      #
+      # @raise MethodNotFoundException
+      #
+      # @return Integer
+      #
       def read
         pin.read
       end
 
+      ##
+      # @see #read
+      #
       def value
         read
       end
+
+      ##
+      # Convenience method to grab the first pin in the pins array
+      #
+      # @return BBB::Pins::AnalogPin
+      #
+      def pin
+        pins.first
+      end
     end
   end
 end

data/lib/BBB/components/led.rb

@@ -1,31 +1,61 @@
 module BBB
   module Components
+    ##
+    # The LED class is the component interface into a digital pin. In a way it's
+    # nothing more than a straight forward port of a digital pin. You can use a
+    # led component when you want to use digital pins, or simply define your own
+    # class and extend it from the LED.
+    #
+    # The Led class does not perform any sort of caching or smart calls, it
+    # forwards everything to the pin. In your own applications you might want to
+    # tune this behavior by adding some kind of caching.
+    #
     class Led
       include Pinnable
-      attr_reader :state, :pin
 
-      def initialize
-        @state = :low
-        @pin = BBB::IO::DigitalPin.new(:output)
-        @pins = [@pin]
+      uses BBB::Pins::DigitalOutputPin
+
+      ##
+      # Convenience method to grab the first pin in the pins array
+      #
+      # @return BBB::Pins::DigitalOutputPin
+      #
+      def pin
+        pins.first
       end
 
+      ##
+      # Turns on the LED
+      # @return void
+      #
       def on!
         pin.on!
-        @state = :high
       end
 
+      ##
+      # Turns off the LED
+      # @return void
+      #
       def off!
         pin.off!
-        @state = :low
       end
 
+      ##
+      # Checks if the LED is turned on.
+      #
+      # @return Boolean
+      #
       def on?
-        state == :high
+        pin.on?
       end
 
+      ##
+      # Checks if the LED is turned off.
+      #
+      # @return Boolean
+      #
       def off?
-        state == :low
+        pin.off?
       end
 
     end

data/lib/BBB/components/pinnable.rb

@@ -3,13 +3,99 @@ module BBB
     module Pinnable
       attr_reader :pins
 
-      def register_pin_positions(*positions)
-        positions.flatten!
-        pins.each_with_index do |pin, index|
-          pin.position=positions[index]
+      module ClassMethods
+        ##
+        # Register the use of classes of pins to a class. These classes will be
+        # initialized upon #initialize_pins
+        #
+        # @param pin_classes [Array<Class>] the classes to register on class
+        #   level.
+        #
+        def uses(*pin_classes)
+          pins.concat(pin_classes)
         end
+
+        ##
+        # Attribute reader to the class level @pins
+        #
+        # @return Array<Class>
+        #
+        def pins
+          @pins ||= []
+        end
+      end
+
+      def self.included(base)
+        base.extend(ClassMethods)
       end
 
+      ##
+      # Initialize the pin classes with their positions and options. Turning
+      # them from their Classes into working pin instances.
+      #
+      # The argument list of the methods is a bit odd. Since it's not
+      # possible to have both a splat and an option array as arguments, the
+      # method signature only shows a splat of positions. The options are then
+      # taken out of the positions, if the last position is actually a Hash as
+      # opposed to a Symbol. If the last element of the positions list is not
+      # a Hash, the options are set to an empty hash.
+      #
+      # @param positions [Array<Symbol>] positions the pins should be
+      #   initialized with.
+      # @param opts [Hash] Options to pass along to the pins during
+      #   initialization.
+      #
+      # @return Array[Pins]
+      #
+      def initialize_pins(*positions)
+        opts = positions.last.kind_of?(Hash) ? positions.pop : {}
+
+        verify_pin_position_count(positions)
+
+        @pins = []
+        self.class.pins.each_with_index do |pin, index|
+          @pins << pin.new(positions[index], opts)
+        end
+        after_pin_initialization
+      end
+
+      ##
+      # Verifies if the number of pins registered in the @pins array match with
+      # the number of pins provided as an argument to the method. This function
+      # normally gets called as part of the initialize pins method to verify if
+      # the positions given to the initialize_pins method matches the number of
+      # registered pins.
+      #
+      # @param positions [Array<Symbol>] The array of positions
+      #
+      # @raise [PinsDoNotMatchException] If the pin counts between the positions
+      #   provided as an argument and the pins in the pins array do not match,
+      #   this exception gets raised, to prevent hard to debug situations later
+      #   on in the lifecycle of an application.
+      #
+      # @return Void
+      def verify_pin_position_count(positions)
+        if self.class.pins.count != positions.count
+          raise PinsDoNotMatchException,
+            "#{self.class.to_s} requires #{self.class.pins.count} but received #{positions.count} pin position."
+        end
+      end
+
+      ##
+      # Method which classes can overwrite to hook into the after pin
+      # initialization
+      #
+      def after_pin_initialization
+      end
+
+      ##
+      # Method that is used in the test suite to test if the pinnable module is
+      # included in an object
+      #
+      # @return true
+      def pinnable?
+        true
+      end
     end
   end
 end

data/lib/BBB/components/servo.rb

@@ -0,0 +1,43 @@
+module BBB
+  module Components
+    class Servo
+      include Pinnable
+      #uses Pins::PWMPin
+      attr_reader :min_duty, :max_duty, :period
+
+      def initialize(period=17e6, min_duty=14.6e6, max_duty=16.6e6)
+        @period   = period
+        @min_duty = min_duty
+        @max_duty = max_duty
+      end
+
+      def after_pin_initialization
+        pin.period = 17e6
+        pin.duty   = (min_duty + duty_range / 2)
+        pin.run    = 0
+      end
+
+      def angle(degrees)
+        value = degrees / 180.to_f * duty_range + min_duty
+        pin.duty = value
+      end
+
+      def activate!
+        pin.run = 1
+      end
+
+      def deactivate!
+        pin.run = 0
+      end
+
+      def pin
+        pins.first
+      end
+
+      def duty_range
+        max_duty - min_duty
+      end
+
+    end
+  end
+end