BBB 0.1.3 → 0.2.0

data/lib/BBB/application.rb

@@ -1,33 +1,17 @@
 module BBB
   class Application
-
-    def self.circuit(circuit)
-      @_circuit = circuit
-      define_convenience_methods(circuit)
-    end
-
-    def self._circuit
-      @_circuit
-    end
-
-    def self.define_convenience_methods(c)
-      c.components.keys.each do |name|
-        define_method(name) do
-          circuit.send(name)
-        end
-      end
-    end
-
-    def circuit
-      self.class._circuit
-    end
+    include Attachable
 
     def start
+      activate_components
       loop do
         run
       end
     end
 
+    def activate_components
+    end
+
     def run
       raise NotImplementedError
     end

data/lib/BBB/circuit.rb

@@ -1,9 +1,56 @@
 module BBB
+  module Attachable
+    module ClassMethods
+
+      def class_components
+        @class_components ||= {}
+      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.
+      # @options opts [Symbol] :as The name of the component
+      #
+      def attach(object, opts={})
+        name   = opts.delete(:as)
+        class_components[name] = object
+        define_method_for_object(object, name)
+      end
+
+      def define_method_for_object(component, name)
+        define_method(name) do
+          value = components[name]
+          return value if value
+
+          object = self.class.class_components[name]
+          value = object.kind_of?(Class) ? object.new : object
+
+          components[name] = value
+        end
+      end
+    end
+
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def components
+      @components ||= {}
+    end
+
+  end
+
   ##
   # 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 component gets attached to
+  # DigitalInput or AnalogOutput. And then, when the component gets connected 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
@@ -12,46 +59,6 @@ module BBB
   # boards. For example by mapping P8_3 on BBB to P1 on an Arduino.
   #
   class Circuit
-    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.
-    # @options opts [Symbol] :as The name of the component
-    #
-    def attach(component, opts={})
-      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)
-
-      component.initialize_pins(pin_positions, pin_options)
-      define_method_for_component(component, name)
-    end
-
-    def define_method_for_component(component, name)
-      components[name] = component
-      eigenclass = class << self; self; end
-      eigenclass.class_eval do
-        define_method(name) do
-          components[name]
-        end
-      end
-    end
-
+    include Attachable
   end
 end

data/lib/BBB/components.rb

@@ -0,0 +1,9 @@
+require "BBB/components/pinnable"
+require "BBB/components/button"
+require "BBB/components/analog_component"
+require "BBB/components/led"
+require "BBB/components/esc"
+require "BBB/components/servo"
+require "BBB/components/wii_motion_plus"
+require "BBB/components/nunchuck"
+

data/lib/BBB/components/analog_component.rb

@@ -31,15 +31,6 @@ module BBB
       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/button.rb

@@ -0,0 +1,25 @@
+module BBB
+  module Components
+    class Button
+      include Pinnable
+
+      uses BBB::Pins::DigitalInputPin
+
+      def high?
+        pin.on?
+      end
+      alias_method :on?, :high?
+
+      def low?
+        !high
+      end
+      alias_method :off?, :low?
+
+      def status
+        pin.status
+      end
+      alias_method :state, :status
+    end
+  end
+end
+

data/lib/BBB/components/esc.rb

@@ -2,45 +2,94 @@ module BBB
   module Components
     class ESC
       include Pinnable
-      uses Pins::PWMPin, Pins::DigitalOutputPin
+      uses Pins::PWMPin
 
       attr_accessor :min_duty, :max_duty, :period
-      attr_reader :duty
 
-      def initialize(period=10e6, min_duty=0.8e6, max_duty=2e6)
-        @period   = period
-        @min_duty = min_duty
-        @max_duty = max_duty
-      end
+      after_connect :setup_pin
 
-      def after_pin_initialization
-        power.off!
-        pwm.period = period
-        pwm.duty   = min_duty
-        pwm.run    = 1
+      ##
+      # Initialize a new ESC using default values for period, min_duty and
+      #   max_duty if present. Please beware that at initialization stage there
+      #   is no initialized PWM pin yet. So you can set the period and the
+      #   min/max_duty instance variables, but not the variables on the pin.
+      #   Only after "connecting" the esc to a board can you set the duty and
+      #   period of the pin. Use the "after pin initialization" method for that.
+      #
+      def initialize(options={})
+        set_options
+
+        @period = options.fetch(:period, 20e6)
+        @speed  = 0
+
+        @min_duty = options.fetch(:min_duty, 17.5e6)
+        @max_duty = options.fetch(:max_duty, 19e6)
       end
 
       def speed(value)
-        self.duty = min_duty + value * duty_range
+        @speed = value
+        @duty = max_duty - value * duty_range
+        synchronize_duty
+      end
+
+      def calibrate
+        pwm.run = 0
+        puts "Disconnect the battery of the motor (press any key)"; gets
+        puts "Get ready to connect the battery after 2 seconds, ready? (press any key)"; gets
+        speed(1)
+        pwm.run = 1
+        puts "one missisipi"; sleep(1)
+        puts "two missisipi"; sleep(1)
+        puts "connect the battery"; sleep(1)
+        speed(0)
+        puts "Calibrated and ready to go"
+      end
+
+      def arm
+        pwm.run=1
+      end
+
+      def armed?
+        pwm.run == 1
+      end
+
+      def disarm
+        pwm.run=0
+      end
+
+      def disarmed?
+        !armed?
       end
 
       def duty=(value)
         @duty = value
-        pwm.duty = @duty
+        synchronize_duty
       end
 
-      def duty_range
-        max_duty - min_duty
+      def period=(value)
+        @period = value
+        synchronize_period
       end
 
       def pwm
-        pins.first
+        pin
       end
 
-      def power
-        pins.last
+      private
+
+      def duty_range
+        max_duty - min_duty
+      end
+
+      def synchronize_period
+        pwm.period = @period
       end
 
+      def after_pin_initialization
+        disarm
+        synchronize_period
+        speed(0)
+      end
     end
   end
 end

data/lib/BBB/components/led.rb

@@ -15,15 +15,6 @@ module BBB
 
       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

data/lib/BBB/components/nunchuck.rb

@@ -0,0 +1,197 @@
+module BBB
+  module Components
+    class Nunchuck
+      include Pinnable
+      uses Pins::I2C
+
+      attr_reader :accelerometer, :controls
+
+      def initialize(options={})
+        @started       = false
+        @positions     = options[:i2c] || []
+        @accelerometer = Accelerometer.new
+        @controls      = Controls.new
+        @decoder       = Decoder.new
+      end
+
+      def start
+        begin
+          raw_read
+        rescue I2C::AckError
+          i2c.write(0x52, 0x40, 0x00)
+        end
+        @started = true
+      end
+
+      def started?
+        @started
+      end
+
+      def update
+        bytes = raw_read.bytes.to_a
+        @accelerometer.update(bytes)
+        @controls.update(bytes)
+      end
+
+      def raw_read
+        decoder.decode i2c.read(0x52, 6, 0x00)
+      end
+
+      def z; controls.z; end
+      def c; controls.c; end
+      def x; controls.x; end
+      def y; controls.z; end
+      def accel; accelerometer; end
+
+      class Decoder
+        def decode(bytes)
+          bytes.map{|b| b^0x17 + 0x17}
+        end
+      end
+
+      class Accelerometer
+        def initialize
+          @x = AccelAccess.new
+          @y = AccelAccess.new
+          @z = AccelAccess.new
+        end
+
+        def update(bytes)
+          set_x(bytes)
+          set_y(bytes)
+          set_z(bytes)
+        end
+
+        def set_x(bytes)
+          value = (bytes[2] << 2) | ((bytes[5] & 0b00001100) >> 2)
+          x.update(value)
+        end
+
+        def set_y(bytes)
+          value = (bytes[3] << 2) | ((bytes[5] & 0b00110000) >> 4)
+          y.update(value)
+        end
+
+        def set_z(bytes)
+          value = (bytes[4] << 2) | ((bytes[5] & 0b11000000) >> 6)
+          z.update(value)
+        end
+
+        class AccelAccess
+          attr_reader :value
+
+          def update(value)
+            @value = value
+          end
+        end
+      end
+
+      class Controls
+        def initialize
+          initialize_buttons
+          initialize_axis
+        end
+
+        def initialize_buttons
+          @buttons = Hash.new
+          @buttons[:z] = Button.new
+          @buttons[:c] = Button.new
+        end
+
+        def c
+          @buttons[:c]
+        end
+
+        def z
+          @buttons[:z]
+        end
+
+        def initialize_axis
+          @axis = Hash.new
+          @axis[:x] = ControlAxis.new
+          @axis[:y] = ControlAxis.new
+        end
+
+        def update(bytes)
+          update_buttons(bytes)
+          update_axis(bytes)
+        end
+
+        def update_buttons(bytes)
+          x = bytes[5] & 0b00000010 >> 1
+          y = bytes[5] & 0b00000001
+
+          @buttons[:x].update(x)
+          @buttons[:y].update(y)
+        end
+
+        def update_axis(bytes)
+          @axis[:x].update(bytes[0])
+          @axis[:y].update(bytes[1])
+        end
+
+        class Button
+          attr_reader :status
+          attr_accessor :release_callbacks, :press_callbacks
+
+          def initialize
+            @status = :released
+            @release_callbacks = []
+            @press_callbacks = []
+          end
+
+          def pressed?
+            status == :pressed
+          end
+
+          def press!
+            @status = :pressed
+            on_press if old_state != status
+          end
+
+          def release!
+            old_state = status
+            @status = :released
+            on_release if old_state != status
+          end
+
+          def released?
+            !pressed
+          end
+
+          def update(value)
+            value == true ? release! : press!
+          end
+
+          def on_release
+            @release_callbacks.each{ |c| c.call(status) }
+          end
+
+          def on_press
+            @press_callbacks.each{ |c| c.call(status) }
+          end
+
+        end
+
+        class ControlAxis
+          attr_accessor :value
+          attr_accessor :change_callbacks
+
+          def initialize
+            @change_callbacks = []
+          end
+
+          def update(value)
+            old_value = self.value
+            @value = value
+            on_change if old_value != value
+          end
+
+          def on_change
+            @change_callbacks.each{|c| c.call(value) }
+          end
+        end
+      end
+    end
+  end
+end