BBB 0.0.10 → 0.1.0

data/lib/BBB/adc/setup.rb

@@ -1,20 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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.respond_to?(:mode) && pin.mode == :output
-        end
-      end
-
-      def connect_io_pin(pin)
-        converted_pin   = pin_converter.convert(pin)
-        pin.pin_io = converted_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

@@ -1,203 +0,0 @@
-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

@@ -1,20 +0,0 @@
-module BBB
-  module Board
-    class PinMapper
-      ##
-      # Thanks to BoneScript, see the resources/pin_mappings.json.comment
-      # for reference to the original BoneScript file.
-      #
-      pin_mapping_file = File.expand_path("../../../../resources/pin_mappings.json", __FILE__)
-      MAP = JSONPinMapper.convert(pin_mapping_file)
-
-      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

@@ -1,12 +0,0 @@
-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/gpio/base.rb

@@ -1,56 +0,0 @@
-module BBB
-  module GPIO
-    class Base
-      attr_reader :position, :converted_position
-      attr_reader :file_class
-
-      def initialize(position=nil, opts={})
-        initialize_base(position, opts)
-      end
-
-      def initialize_base(pin_position, opts)
-        @mock = opts.fetch(:mock, false)
-        self.position = pin_position
-        @file_class = @mock ? StringIO : File
-        export
-      end
-
-      def position=(position, mock=false)
-        @position = position
-        @converted_position = Board::PinMapper.map(position).gpio
-      end
-
-      def gpio_path
-        "/sys/class/gpio"
-      end
-
-      def export_path
-        gpio_path + "/export"
-      end
-
-      def unexport_path
-        gpio_path + "/unexport"
-      end
-
-      def gpio_direction_input
-        "in"
-      end
-
-      def gpio_direction_output
-        "out"
-      end
-
-      def gpio_pin_dir
-        "#{gpio_path}/gpio#{converted_position}"
-      end
-
-      def export
-        file_class.open(export_path, "w") { |f| f.write("#{ converted_position }") }
-      end
-
-      def unexport
-        file_class.open(unexport_path, "w") { |f| f.write("#{converted_position}") }
-      end
-    end
-  end
-end

data/lib/BBB/gpio/digital_pin.rb

@@ -1,69 +0,0 @@
-module BBB
-  module GPIO
-    class DigitalPin < Base
-      attr_reader :mode, :io
-
-      def initialize(position, mode, opts={})
-        initialize_base(position, opts)
-        @mode = validate_mode(mode)
-        set_mode
-      end
-
-      def direction
-        case mode
-        when :input
-          gpio_direction_input
-        when :output
-          gpio_direction_output
-        end
-      end
-
-      def file_mode
-        case mode
-        when :input
-          "r"
-        when :output
-          "w+"
-        end
-      end
-
-      def set_mode
-        direction_file = gpio_pin_dir + "/direction"
-        file_class.open(direction_file, "w") {|f| f.write(direction); f.flush}
-      end
-
-      def io
-        return @io unless @io.nil?
-
-        value_file     = gpio_pin_dir + "/value"
-        @io = file_class.open(value_file, file_mode)
-      end
-
-      def write(value)
-        io.rewind
-        io.write value_map[value]
-        io.flush
-      end
-
-      def read
-	io.rewind
-        value_map[io.read]
-      end
-
-      private
-
-      def validate_mode(mode)
-        if [:input, :output].include?(mode)
-          return mode
-        else
-          raise UnknownPinModeException, "Pin mode: #{mode} is now known"
-        end
-      end
-
-      def value_map
-        @value_map ||= {:high=>1, :low=>0, 1=>:high, 0=>:low}
-      end
-
-    end
-  end
-end

data/lib/BBB/gpio/pin_converter.rb

@@ -1,28 +0,0 @@
-module BBB
-  module GPIO
-    class PinConverter
-      attr_reader :mock
-
-      def initialize(opts={})
-        @mock = opts.fetch(:mock, false)
-      end
-
-      ##
-      # Currently only converts IO::DigitalPins
-      #
-      def convert(pin, opts={})
-        opts = {:mock=>mock}.merge(opts)
-
-        base_class = pin.class.to_s.split("::").last
-        if GPIO.const_defined?(base_class)
-          klass = GPIO::const_get(base_class.to_sym)
-          return klass.new(pin.position, pin.mode, opts)
-        elsif ADC.const_defined?(base_class)
-          klass = ADC::const_get(base_class.to_sym)
-          return klass.new(pin.position, opts)
-        end
-      end
-
-    end
-  end
-end