BBB 0.1.3 → 0.2.0

data/lib/BBB/components/pinnable.rb

@@ -2,17 +2,18 @@ module BBB
   module Components
     module Pinnable
       attr_reader :pins
+      attr_reader :positions
 
       module ClassMethods
         ##
         # Register the use of classes of pins to a class. These classes will be
-        # initialized upon #initialize_pins
+        # initialized upon #connect
         #
-        # @param pin_classes [Array<Class>] the classes to register on class
+        # @param classes [Array<Class>] the classes to register on class
         #   level.
         #
-        def uses(*pin_classes)
-          pins.concat(pin_classes)
+        def uses(*classes)
+          pin_classes.concat(classes)
         end
 
         ##
@@ -20,9 +21,26 @@ module BBB
         #
         # @return Array<Class>
         #
-        def pins
-          @pins ||= []
+        def pin_classes
+          @pin_classes ||= []
         end
+
+        ##
+        # Register callbacks
+        #
+        def after_connect(callback)
+          after_connect_callbacks << callback
+        end
+
+        ##
+        # Convenience function on class level that holds the callbacks (anything
+        # that responds to call OR a symbol) that need to be called after the
+        # pins get connected.
+        #
+        def after_connect_callbacks
+          @after_connect_callbacks ||= []
+        end
+
       end
 
       def self.included(base)
@@ -47,24 +65,29 @@ module BBB
       #
       # @return Array[Pins]
       #
-      def initialize_pins(*positions)
+      def connect(*positions)
+        positions = self.positions if positions.empty?
+
         positions.flatten!
         opts = positions.last.kind_of?(Hash) ? positions.pop : {}
 
         verify_pin_position_count(positions)
 
         @pins = []
-        self.class.pins.each_with_index do |pin, index|
+        self.class.pin_classes.each_with_index do |pin, index|
           @pins << pin.new(positions[index], opts)
         end
-        after_pin_initialization
+        after_connect_callbacks
+        return self # so that we can chain it with the initializer
       end
 
+      alias_method :pin_initialization, :connect
+
       ##
       # 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
+      # the positions given to the connect method matches the number of
       # registered pins.
       #
       # @param positions [Array<Symbol>] The array of positions
@@ -76,17 +99,20 @@ module BBB
       #
       # @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."
+        if self.class.pin_classes.count != positions.count
+          fail PinsDoNotMatchException,
+            "#{self.class.to_s} requires #{self.class.pin_classes.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
+      def after_connect_callbacks
+        self.class.after_connect_callbacks.each do |callback|
+          if callback.responds_to?(:call)
+            callback.call
+          else
+            self.send(callback)
+          end
+        end
       end
 
       ##
@@ -94,9 +120,35 @@ module BBB
       # included in an object
       #
       # @return true
+      #
       def pinnable?
         true
       end
+
+      ##
+      # Convenience method to grab the first pin in the pins array
+      #
+      # @return BBB::Pins::AnalogPin
+      #
+      def pin
+        pins.first
+      end
+
+      ##
+      # Provide a default initializer
+      #
+      def initialize(options={})
+        set_options(options)
+      end
+
+      ##
+      # Provide a function to handle the options
+      #
+      # @param options [Hash]
+      #
+      def set_options(options)
+        @positions = [options.fetch(:pin, nil)].compact
+      end
     end
   end
 end

data/lib/BBB/components/servo.rb

@@ -3,18 +3,21 @@ module BBB
     class Servo
       include Pinnable
       uses Pins::PWMPin
-      attr_reader :min_duty, :max_duty, :period
+      attr_reader :period, :min_duty, :max_duty, :max_degrees
 
-      def initialize(period=17e6, min_duty=14.6e6, max_duty=16.6e6)
-        @period   = period
-        @min_duty = min_duty
-        @max_duty = max_duty
-      end
+      ##
+      # Min duty and max duty for FS5103B servo
+      # duty cycle of 900 to 2100 ms for 120 degrees
+      # http://www.servodatabase.com/servo/feetech/fs5103b
+      #
+      def initialize(options={})
+        set_options(options)
+
+        @period      = options.fetch(:period, 20e6)
+        @min_duty    = options.fetch(:min_duty, 17.9e6)
+        @max_duty    = options.fetch(:max_duty, 19.1e6)
+        @max_degrees = options.fetch(:max_degrees, 120)
 
-      def after_pin_initialization
-        pin.period = 17e6
-        pin.duty   = (min_duty + duty_range / 2)
-        pin.run    = 1
       end
 
       def angle(degrees)
@@ -22,7 +25,7 @@ module BBB
       end
 
       def degrees_to_ns(degrees)
-        degrees / 180.to_f * duty_range + min_duty
+        degrees / max_degrees.to_f * duty_range + min_duty
       end
 
       def activate!
@@ -37,10 +40,17 @@ module BBB
         pins.first
       end
 
+      private
+
       def duty_range
         max_duty - min_duty
       end
 
+      def after_pin_initialization
+        pin.period = self.period
+        pin.duty   = (min_duty + duty_range / 2)
+        pin.run    = 1
+      end
     end
   end
 end

data/lib/BBB/components/wii_motion_plus.rb

@@ -0,0 +1,229 @@
+module BBB
+  module Components
+    ##
+    # WiiMotionPlus I2C component. Attach to P9 like this:
+    #  Nunchuck/ WMP connector:
+    # ---------
+    # | 1 2 3 |
+    # |       |
+    # | 6 5 4 |
+    # | ----- |
+    # |_|   |_|
+    #
+    # Connections from NunChuck to BeagleBone "P9" connector:
+    #
+    # pin 1: green: system data - connect to BeagleBone pin 20 (I2C2_SDA)
+    # pin 2: (not connected)
+    # pin 3: red: DC 3.3V supply - to BeagleBone pin 3 or pin 4 (DC_3.3V)
+    # pin 4: yellow - system clock - to BeagleBone pin 19 (I2C2_SCL)
+    # pin 5: ("ATT" - not needed)
+    # pin 6: white - GND - to BeagleBone pin 1 or pin 2 (GND)
+    #
+    # Copied from: http://www.alfonsomartone.itb.it/mzscbb.html
+    #
+    class WiiMotionPlus
+      include Pinnable
+      uses Pins::I2C
+
+      attr_reader :gyro, :positions
+
+      def initialize(options = {})
+        @started = false
+        @calibrated = false
+        @gyro = Gyro.new
+        @positions = [options.fetch(:i2c, nil)].compact
+      end
+
+      def start
+        begin #check if we can already read, if so, we're already started.
+          raw_read
+        rescue I2C::AckError
+          i2c.write(0x53, 0xfe, 0x04)
+        end
+        @started = true
+      end
+
+      def started?
+        @started
+      end
+
+      def calibrated?
+        @calibrated
+      end
+
+      def calibrate(number=20)
+        start unless started?
+        @gyro.start_calibration!
+        number.times do
+          update
+        end
+        @gyro.stop_calibration!
+        @calibrated = true
+      end
+
+      def update
+        bytes = raw_read.bytes.to_a
+        @gyro.update(bytes)
+        set_extension(bytes)
+      end
+
+      def set_extension(bytes)
+        @extension_set = bytes[4] & 0b00000001
+      end
+
+      def i2c   ; pins.first ; end
+      def pitch ; gyro.pitch ; end
+      def yaw   ; gyro.yaw   ; end
+      def roll  ; gyro.roll  ; end
+
+      def raw_read
+        i2c.read(0x52, 6, 0x00)
+      end
+
+      class AxisValue
+        attr_reader :value, :slow, :zero_value
+
+        MAX_AMPLITUDE   = 8192 # half of a 14 bit integer
+        MAX_MEASUREMENT = 519 # degrees / second
+        FACTOR = MAX_AMPLITUDE / MAX_MEASUREMENT
+
+        def initialize
+          @value = 0
+          @slow = 0
+          @zero_value = 8063 # has to be adjusted during calibration
+          @calibration_values = []
+        end
+
+        def update(value, slow)
+          @value = value
+          @slow = slow
+          @calibration_values << value if @calibrating
+        end
+
+        def degrees
+          value / FACTOR * slow_correction
+        end
+
+        def value
+          @value - @zero_value
+        end
+
+        def start_calibration!
+          @calibrating = true
+        end
+
+        def stop_calibration!
+          @calibrating = false
+          arr = @calibration_values
+          @zero_value = arr.inject(0) { |sum, el| sum + el } / arr.size
+          @calibration_values = []
+        end
+
+        # At high speed (slow bit = 0) raw values read are small with the same
+        # deg/s to reach higher values on top, so you must multiply it by
+        # 2000/440 (they are the max reference in the two modes in deg/s [1]).
+        #
+        # Example: reading 8083 raw value and assuming 8063 as zero, 20 unit in
+        # slow/normal mode are 1,45 deg/s and in fast mode are
+        # 1.45*2000/440=6.59 deg/s.
+        #
+        def slow_correction
+          slow ? 2000/440 : 1
+        end
+      end
+
+      #
+      # DATA FORMAT WII MOTION PLUS (GYRO)
+      #
+      # as taken from:
+      # http://wiibrew.org/wiki/Wiimote/Extension_Controllers/Wii_Motion_Plus
+      #
+      # The YAW, PITCH and ROLL values are 14 bit integers
+      # (maximum value = 2^14 - 1 = 16383).
+      #
+      # The first 8 bits are available in the first Byte. The last 6 bits are
+      # available in bits 8 to 13 in byte 3.
+      #
+      # Bit positions count from right to left. So bit position 0 is the most
+      # 'right' bit, and bit 13 bit is the most 'left' bit.
+      #
+      # this is also why you see the <13:8> position definition in bytes 3,4 and 5.
+      #
+      # |------|--------------------------------------------------------------|
+      # |      |                              Bit                             |
+      # |------|--------------------------------------------------------------|
+      # | Byte |  7   |   6   |   5   |   4   |   3   |   2   |   1   |   0   |
+      # |------|--------------------------------------------------------------|
+      # |  0   |                  Yaw Down Speed<7:0>                         |
+      # |------|--------------------------------------------------------------|
+      # |  1   |                  Roll Left Speed<7:0>                        |
+      # |------|--------------------------------------------------------------|
+      # |  2   |                  Pitch Left Speed<7:0>                       |
+      # |------|--------------------------------------------------------------|
+      # |  3   |              Yaw Down Speed<13:8>            | yaw   | pitch |
+      # |      |                                              | slow  | slow  |
+      # |      |                                              | mode  | mode  |
+      # |------|--------------------------------------------------------------|
+      # |  4   |              Roll left speed<13:8>           | roll  | ext.  |
+      # |      |                                              | slow  | conn- |
+      # |      |                                              | mode  | ected |
+      # |------|--------------------------------------------------------------|
+      # |  5   |              Pitch left speed<13:8>          |   1   |   0   |
+      # |------|--------------------------------------------------------------|
+      #
+      #
+      class Gyro
+        HIGH_MASK = 0b11111100
+
+        attr_reader :yaw, :pitch, :roll
+
+        def initialize
+          @yaw   = AxisValue.new
+          @pitch = AxisValue.new
+          @roll  = AxisValue.new
+          @calibrating = false
+        end
+
+        def calibrating?
+          @calibrating
+        end
+
+        def start_calibration!
+          @calibrating = true
+          [yaw,pitch,roll].each(&:start_calibration!)
+        end
+
+        def stop_calibration!
+          [yaw,pitch,roll].each(&:stop_calibration!)
+          @calibrating = false
+        end
+
+        def update(bytes)
+          set_yaw(bytes)
+          set_pitch(bytes)
+          set_roll(bytes)
+        end
+
+        def set_yaw(bytes)
+          value = (bytes[3] & HIGH_MASK) << 6 | bytes[0]
+          slow = bytes[3] & 0b00000010 >> 1
+          yaw.update(value, slow)
+        end
+
+        def set_pitch(bytes)
+          value = (bytes[4] & HIGH_MASK) << 6 | bytes[1]
+          slow = bytes[3] & 0b00000001
+          pitch.update(value, slow)
+        end
+
+        def set_roll(bytes)
+          value = (bytes[5] & HIGH_MASK) << 6 | bytes[2]
+          slow = bytes[4] & 0b00000010 >> 1
+          roll.update(value, slow)
+        end
+
+      end
+    end
+    WMP = WiiMotionPlus
+  end
+end

data/lib/BBB/pins.rb

@@ -0,0 +1,13 @@
+require "BBB/pins/io/pin_mapper"
+require "BBB/pins/io/mapped"
+require "BBB/pins/io/cape"
+require "BBB/pins/io/ain"
+require "BBB/pins/io/gpio"
+require "BBB/pins/io/pwm"
+require "BBB/pins/io/i2c"
+
+require "BBB/pins/pinnable"
+require "BBB/pins/digital_pin"
+require "BBB/pins/analog_pin"
+require "BBB/pins/pwm_pin"
+require "BBB/pins/i2c"