BBB 0.0.3 → 0.0.4

data/.travis.yml

@@ -1,7 +1,7 @@
 language: ruby
 rvm:
   - 1.9.3
-  - jruby-19mode
-  - rbx-19mode
+  - 2.0.0
+  - rbx-2.2.1
   - ruby-head
   - jruby-head

data/Gemfile

@@ -6,4 +6,6 @@ gem 'coveralls', require: false
 
 group :test do
   gem 'pry'
+  gem 'rubysl', :platform => :rbx
+  gem 'racc', :platform => :rbx
 end

data/examples/analog_pin.rb

@@ -0,0 +1,31 @@
+require 'BBB'
+
+##
+# Setup the AnalogPin Circuit
+#
+class Circuit < BBB::Circuit
+  def initialize
+    # Attach temperature sensor to pin P9_40
+    attach BBB::Components::Analog, pin: :P9_40, as: :thermometer
+  end
+end
+
+##
+# Setup the actual Applicaiton
+#
+class TemperatureExampleApp < BBB::Application
+  # Run this on the BeagleBoneBlack
+  board BBB::Board.new
+
+  # Connect the circuit to the board
+  circuit Circuit.new
+
+  # This is the basic run loop
+  def run
+    puts thermometer.read
+  end
+end
+
+# Initialize the app
+app = TemperatureExampleApp.new
+app.start

data/examples/led.rb

@@ -17,7 +17,7 @@ class LedExampleApplication < BBB::Application
   # Run this on the BeableBoneBlack
   board BBB::Board.new
 
-  # Connection the led circuit
+  # Connect the led circuit
   circuit Circuit.new
 
   # This is the basic run loop

data/examples/sketches.rb

@@ -73,8 +73,8 @@ module Thunderball
 
   def Stabalizer
     def initialize(opts={})
-      @escs = opts[:escs]
-      @gyo = opts[:gyro]
+      @escs          = opts[:escs]
+      @gyo           = opts[:gyro]
       @accelerometer = opts[:accelerometer]
     end
 

data/lib/BBB/adc/analog_pin.rb

@@ -0,0 +1,41 @@
+module BBB
+  module ADC
+    class AnalogPin
+      attr_reader :position, :pin_map, :mock
+      attr_reader :file_handle
+
+      def initialize(position, opts={})
+        self.position = position
+        @mock         = opts.fetch(:mock, false)
+        @file_handle  = get_file_handle(mock)
+      end
+
+      def position=(position)
+        map = Board::PinMapper.map(position, :ain)
+        unless map.respond_to?(:ain) && !map.ain.nil?
+          raise ArgumentError, "#{position} is not a valid AIN pin position"
+        end
+
+        @pin_map = map
+        @position = position
+      end
+
+      def ain_path
+        "/sys/devices/ocp.3/helper.15/AIN#{pin_map.ain}"
+      end
+
+      def read
+        file_handle.read
+      end
+
+      def scale
+        pin_map.scale
+      end
+
+      def get_file_handle(mock=false)
+        mock ? StringIO.new : File.open(ain_path, "r")
+      end
+
+    end
+  end
+end

data/lib/BBB/adc/setup.rb

@@ -0,0 +1,20 @@
+module BBB
+  module ADC
+    def self.setup
+      check_if_kernel_module_is_loaded!
+    end
+
+    def self.check_if_kernel_module_is_loaded!
+      ains = `find /sys/ -name '*AIN*'`.split("\n")
+
+      if ains.size > 0
+        return true
+      else
+        raise ModuleNotLoadedException, "Is seems that the ADC module is not
+          loaded into the kernel. You might want to try: \n
+          sudo modprobe t1_tscadc or add it to the kernel on boot: \n
+          echo 't1_tscadc' >> /etc/modules.conf"
+      end
+    end
+  end
+end

data/lib/BBB/board/base.rb

@@ -0,0 +1,45 @@
+module BBB
+  module Board
+    ##
+    # Base class, designed and tested on BeagleBone Black Revision A5C
+    #
+    class Base
+      attr_reader :gpio, :pin_converter
+
+      def initialize(pin_converter=nil)
+        @pin_converter = pin_converter || self.class.pin_converter
+        @pins = {}
+      end
+
+      ##
+      # Define methods for a GPIO::PIN
+      #
+      def setup_pin(pin)
+        @pins[pin.position] = pin
+
+        metaclass = class << self; self; end
+        metaclass.class_eval do
+          define_method("p#{pin.position.to_s[1..-1]}") do
+            @pins[pin.position].read
+          end
+
+          define_method("p#{pin.position.to_s[1..-1]}=") do |value|
+            @pins[pin.position].write value
+          end if pin.mode == :output
+        end
+      end
+
+      def connect_io_pin(pin)
+        gpio_pin   = pin_converter.convert(pin)
+        pin.pin_io = gpio_pin
+        setup_pin(pin)
+      end
+
+      private
+
+      def self.pin_converter
+        GPIO::PinConverter.new
+      end
+    end
+  end
+end

data/lib/BBB/board/json_pin_mapper.rb

@@ -0,0 +1,203 @@
+module BBB
+  module Board
+    ##
+    # This class provides a convenient way of mapping a JSON representation of the
+    # pins, taken from the bonescript sourcecode, into Ruby objects. After
+    # converting the json to ruby objects the "normal" PinMapper will take the
+    # object structure and provide the actual mapping from the pin header
+    # positions, like p8_3 to the correct GPIO, I2C or WPM endpoints.
+    #
+    # This class should not be used directly to provide these mappings it's simply
+    # a helper class to get from JSON to Ruby.
+    #
+    class JSONPinMapper
+      class PinMap < Struct.new(:pins, :uart, :i2c); end
+      class Pin    < Struct.new(:name, :gpio, :led, :mux, :key, :mux_reg_offset,
+                                :options, :eeprom, :pwm, :ain, :scale); end
+      class UART   < Struct.new(:devicetree, :rx, :tx); end
+      class I2C    < Struct.new(:devicetree, :path, :sda, :scl); end
+
+      attr_reader :data
+
+      ##
+      # Initialize a JSONPinMapper
+      #
+      # @param [Hash] hash Hash that was converted from json with the keys
+      #   pinIndex, uart and i2c.
+      #
+      def initialize(hash)
+        @data = hash
+      end
+
+      ##
+      # Factor a new JSONPinMapper based on a json_file that get's parsed to a
+      # hash.
+      #
+      # @param [String] json_filename The file that contains the JSON object with
+      #   pin information
+      #
+      # @return JSONPinMapper instance
+      #
+      def self.convert(json_filename)
+        file = File.open(json_filename, "r")
+        hash = JSON.parse(file.read)
+        new(hash).convert
+      end
+
+      ##
+      # Convert from a the data hash to ruby objects
+      #
+      # @return [Struct] with pins, uart and i2c as keys.
+      #   pins has a
+      #
+      def convert
+        pins = convert_pins(data["pinIndex"])
+        uart = convert_uart(data["uarts"])
+        i2c  = convert_i2c(data["i2c"])
+
+        PinMap.new(pins, uart, i2c)
+      end
+
+      ##
+      # Converts an array of pins into a hash with the pin key as a key and a Pin
+      #   Struct as a value.
+      #
+      # Here is an example of a piece of the JSON code containing pin info:
+      #
+      # {
+      #     "name": "USR0",
+      #     "gpio": 53,
+      #     "led": "usr0",
+      #     "mux": "gpmc_a5",
+      #     "key": "USR0",
+      #     "muxRegOffset": "0x054",
+      #     "options": [
+      #         "gpmc_a5",
+      #         "gmii2_txd0",
+      #         "rgmii2_td0",
+      #         "rmii2_txd0",
+      #         "gpmc_a21",
+      #         "pr1_mii1_rxd3",
+      #         "eqep1b_in",
+      #         "gpio1_21"
+      #     ]
+      # }
+      #
+      # @param [Array<Hash>] array An array of Pin hashes
+      #
+      # @return [Hash] a hash with pin keys as keys and pin objects as values.
+      #
+      def convert_pins(array)
+        hash = {}
+
+        array.each do |pin_hash|
+          pin = Pin.new
+          pin_hash.each_pair do |key, value|
+            pin[underscore(key).to_sym] = value
+          end
+          hash[pin.key.upcase.to_sym] = pin
+        end
+
+        return hash
+      end
+
+      ##
+      # Convert a hash of uarts to a hash with the uart folder (e.g. /dev/tty00)
+      #   as the key and an uart object as the value.
+      #
+      # Here is an example of an individual UART hash:
+      #
+      #  "/dev/ttyO1": {
+      #      "devicetree": "BB-UART1",
+      #      "rx": "P9_26",
+      #      "tx": "P9_24"
+      #  }
+      #
+      # @param [Hash] data_hash with strings as keys and hashes as values
+      #
+      # @return [Hash] with strings of uart positions (e.g. /dev/tty00) as keys
+      #   and uart objects as values
+      #
+      def convert_uart(data_hash)
+        convert_hash_with_hashes(data_hash, UART)
+      end
+
+      ##
+      # Convert a hash of I2Cs to a hash with the I2C folder as the key and a i2c
+      #   object as the value
+      #
+      # Here is an example of an individual I2C hash:
+      #
+      #  "/dev/i2c-1": {
+      #      "devicetree": "BB-I2C1",
+      #      "path": "/dev/i2c-2",
+      #      "sda": "P9_18",
+      #      "scl": "P9_17"
+      #  }
+      #
+      # @param [Hash] data_hash with strings as keys and hashes as values
+      #
+      # @return [Hash] with strings of I2C folders as keys and I2C objects as
+      #   values
+      #
+      def convert_i2c(data_hash)
+        convert_hash_with_hashes(data_hash, I2C)
+      end
+
+      private
+
+      ##
+      # @see #convert_uart
+      #
+      def convert_hash_with_hashes(data_hash, object)
+        hash = {}
+
+        data_hash.each_pair do |filesystem, info_hash|
+          instance = object.new
+          info_hash.each_pair do |key, value|
+            instance[key] = value
+          end
+
+          hash[filesystem] = instance
+        end
+
+        return hash
+      end
+
+      ##
+      # Makes an underscored, lowercase form from the expression in the string.
+      #
+      # Gracefully copied from ActiveSupport::Inflections
+      # http://api.rubyonrails.org/classes/ActiveSupport/Inflector.html#method-i-underscore
+      #
+      # Changes '::' to '/' to convert namespaces to paths.
+      #
+      #   'ActiveModel'.underscore         # => "active_model"
+      #   'ActiveModel::Errors'.underscore # => "active_model/errors"
+      #
+      # As a rule of thumb you can think of +underscore+ as the inverse of
+      # +camelize+, though there are cases where that does not hold:
+      #
+      #   'SSLError'.underscore.camelize # => "SslError"
+      def underscore(camel_cased_word)
+        word = camel_cased_word.to_s.dup
+        word.gsub!('::', '/')
+        word.gsub!(/(?:([A-Za-z\d])|^)(#{acronym_regex})(?=\b|[^a-z])/) { "#{$1}#{$1 && '_'}#{$2.downcase}" }
+        word.gsub!(/([A-Z\d]+)([A-Z][a-z])/,'\1_\2')
+        word.gsub!(/([a-z\d])([A-Z])/,'\1_\2')
+        word.tr!("-", "_")
+        word.downcase!
+        word
+      end
+
+      ##
+      # Specifies acronyms. This is a shortcut approach to the full acronym
+      # functionality of Rails. Which can be found here:
+      # https://github.com/rails/rails/blob/4e327225947b933d5434509e02e98226c581adc1/activesupport/lib/active_support/inflector/inflections.rb#L47
+      #
+      def acronym_regex
+        /#{%w(I2C UART GPIO).join("|")}/
+      end
+    end
+  end
+end

data/lib/BBB/board/pin_mapper.rb

@@ -0,0 +1,19 @@
+module BBB
+  module Board
+    class PinMapper
+      ##
+      # Thanks to BoneScript, see the resources/pin_mappings.json.comment
+      # for reference to the original BoneScript file.
+      #
+      MAP = JSONPinMapper.convert("resources/pin_mappings.json")
+
+      def self.map(pin_symbol, type=:gpio)
+        begin
+          MAP.pins.fetch(pin_symbol.upcase.to_sym)
+        rescue Exception => e
+          raise UnknownPinException, "Pin #{pin_symbol} could not be mapped"
+        end
+      end
+    end
+  end
+end

data/lib/BBB/board/test_board.rb

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

data/lib/BBB/exceptions.rb

@@ -2,5 +2,4 @@ module BBB
   class UnknownPinException < ArgumentError; end
   class UnknownPinModeException < ArgumentError; end
   class PinsDoNotMatchException < ArgumentError; end
-  class NotImplementedError < ArgumentError; end
 end

data/lib/BBB/gpio/base.rb

@@ -12,12 +12,12 @@ module BBB
         @mock = opts.fetch(:mock, false)
         self.position = pin_position
         @file_class = @mock ? StringIO : File
-	export
+        export
       end
 
       def position=(position, mock=false)
         @position = position
-        @converted_position = PinMapper.map(position)
+        @converted_position = Board::PinMapper.map(position).gpio
       end
 
       def gpio_path

data/lib/BBB/io/analog_pin.rb

@@ -0,0 +1,23 @@
+module BBB
+  module IO
+    class AnalogPin
+      include Pinnable
+
+      attr_reader :pin_io, :position
+
+      def initialize(pin_io=nil, position=nil)
+        @pin_io = pin_io || MockPin.new
+        @position = position
+      end
+
+      def read
+        pin_io.read
+      end
+
+      def scale
+        pin_io.scale
+      end
+
+    end
+  end
+end

data/lib/BBB/io/digital_pin.rb

@@ -36,11 +36,11 @@ module BBB
 
       # Reads digitally from the specified pin on initialize
       def read
-	if mode == :input
-	  pin_io.read
-	else
+        if mode == :input
+          pin_io.read
+        else
           status
-	end
+        end
       end
 
       # Sets digital write for the pin to HIGH

data/lib/BBB/version.rb

@@ -1,3 +1,3 @@
 module BBB
-  VERSION = "0.0.3"
+  VERSION = "0.0.4"
 end

data/lib/BBB.rb

@@ -1,14 +1,22 @@
 require "BBB/version"
-require "BBB/board"
-require "BBB/test_board"
+
+require "json"
+
+require "BBB/board/base"
+require "BBB/board/test_board"
+require "BBB/board/json_pin_mapper"
+require "BBB/board/pin_mapper"
+
 require "BBB/circuit"
-require "BBB/pin_mapper"
 require "BBB/exceptions"
 
 require "BBB/gpio/base"
 require "BBB/gpio/digital_pin"
 require "BBB/gpio/pin_converter"
 
+require "BBB/adc/setup"
+require "BBB/adc/analog_pin"
+
 require "BBB/io/pinnable"
 require "BBB/io/digital_pin"
 require "BBB/io/mock_pin"