object_oriented_beaglebone_black 0.0.1

data/config/uarts.json

@@ -0,0 +1,31 @@
+// Based on https://github.com/jadonk/bonescript/blob/master/src/bone.js
+// The content is copied from there and key uarts" is added. 
+// The idea of adding that key to make the JSON structure in this file is coming from 
+// https://github.com/Sparkboxx/bbb/blob/master/resources/pin_mappings.json
+{ "uarts" : {
+    "/dev/ttyO0": {
+    },
+    "/dev/ttyO1": {
+        "devicetree": "BB-UART1",
+        "rx": "P9_26",
+        "tx": "P9_24"
+    },
+    "/dev/ttyO2": {
+        "devicetree": "BB-UART2",
+        "rx": "P9_22",
+        "tx": "P9_21"
+    },
+    "/dev/ttyO3": {
+    },
+    "/dev/ttyO4": {
+        "devicetree": "BB-UART4",
+        "rx": "P9_11",
+        "tx": "P9_13"
+    },
+    "/dev/ttyO5": {
+        "devicetree": "BB-UART5",
+        "rx": "P8_38",
+        "tx": "P8_37"
+    }
+  }
+}

data/examples/current_measurement.rb

@@ -0,0 +1,7 @@
+require 'object_oriented_beaglebone_black'
+
+require 'current_measurement/current_input'
+
+module CurrentMeasurement
+  # Your code goes here...
+end

data/examples/current_measurement/current_input.rb

@@ -0,0 +1,16 @@
+require 'bigdecimal'
+
+module CurrentMeasurement
+  class CurrentInput
+
+    def initialize(pin_key)
+      @analog_input = ObjectOrientedBeagleboneBlack::AnalogInput.new(pin_key)
+    end
+
+    def value
+      # Conversion for ACS712 Breakout. If a different current measurement device is used, extract this code to subclass and make this class parent class.
+      (@analog_input.raw_value / BigDecimal("0.185")).to_f
+    end
+
+  end
+end

data/examples/voltage_measurement.rb

@@ -0,0 +1,7 @@
+require 'object_oriented_beaglebone_black'
+
+require 'voltage_measurement/voltage_input'
+
+module VoltageMeasurement
+  # Your code goes here...
+end

data/examples/voltage_measurement/voltage_input.rb

@@ -0,0 +1,16 @@
+require 'bigdecimal'
+
+module VoltageMeasurement
+  class VoltageInput
+
+    def initialize(pin_key)
+      @analog_input = ObjectOrientedBeagleboneBlack::AnalogInput.new(pin_key)
+    end
+
+    def value
+      # For voltage divider 11:1, e.g. 51[kΩ] and 5.1[kΩ]. If another voltage divider is added, extract this code to subclass and make this class parent class. 
+      (@analog_input.raw_value * BigDecimal("11")).to_f
+    end
+
+  end
+end

data/lib/object_oriented_beaglebone_black.rb

@@ -0,0 +1,26 @@
+require "object_oriented_beaglebone_black/version"
+require "erb"
+
+OBJECT_ORIENTED_BEAGLEBONE_BLACK_ROOT = File.expand_path('..', __dir__)
+
+require 'yaml'
+# require 'active_support/core_ext/hash/keys'
+
+ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"] ||= 'development'
+OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG = YAML.load(ERB.new(File.read(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_ROOT, "config", "environments", "#{ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"]}.yml"))).result)
+# YAML.load_file(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_ROOT, "config", "environments", "#{ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"]}.yml"))
+# In order not to use activesupport (since Beaglebone Black that is used currently didn't have Internet access to download it), Hash#deep_symbolize_keys! is not used.
+# OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG.deep_symbolize_keys!
+
+require 'object_oriented_beaglebone_black/pin_mappings'
+require 'object_oriented_beaglebone_black/io'
+require 'object_oriented_beaglebone_black/io/direction'
+require 'object_oriented_beaglebone_black/io/value'
+require 'object_oriented_beaglebone_black/gpio'
+require 'object_oriented_beaglebone_black/led'
+require 'object_oriented_beaglebone_black/pwm'
+require 'object_oriented_beaglebone_black/analog_input'
+
+module ObjectOrientedBeagleboneBlack
+  # Your code goes here...
+end

data/lib/object_oriented_beaglebone_black/analog_input.rb

@@ -0,0 +1,43 @@
+require 'bigdecimal'
+
+module ObjectOrientedBeagleboneBlack
+  class AnalogInput
+    include ObjectOrientedBeagleboneBlack::PinMappings
+
+    def initialize(pin_key)
+      @pin_key = pin_key
+      @slots_file_path = File.join(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["slots_directory"], "slots"))
+
+      activate_device_tree_overlays      
+    end 
+
+    def activate_device_tree_overlays
+      # Note: Since slots file acts as an interface to activate Device Tree Overlay, simply writing to it does what needs to be done. 
+      #       I'm using appending here so that testing in a local environment becomes straightfoward. 
+      File.open(@slots_file_path, "a") { |file| file.write("cape-bone-iio") }
+    end
+
+    def raw_value
+      internal_raw_value = nil
+      File.open(File.join(analog_input_directory, pin_name(@pin_key)), "r") { |file| internal_raw_value = file.read.strip }
+      raw_value = (BigDecimal(internal_raw_value.to_s) / BigDecimal("1000")).to_f
+      raw_value
+    end
+
+    def value
+      # The raw_value is in the range of 0 to 1.8[V]. 
+      # The value is in the range of 0 to 1.0. 
+      (BigDecimal(raw_value.to_s) * (BigDecimal("1.0") / BigDecimal("1.8"))).to_f
+    end
+
+    private
+      def pin_name(pin_key)
+        property_hash(key: pin_key)["name"]
+      end
+
+      def analog_input_directory
+        Dir["#{File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["device_directory"], "helper.")}*"].first
+      end
+
+  end
+end

data/lib/object_oriented_beaglebone_black/gpio.rb

@@ -0,0 +1,40 @@
+module ObjectOrientedBeagleboneBlack
+  class Gpio
+
+    def initialize(pin_number)
+      @pin_number = pin_number
+      @gpio_directory = File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["io_root_directory"], "gpio")
+    end
+
+    def export
+      File.open(File.join(@gpio_directory, "export"), "w") { |file| file.write(@pin_number) }
+    end
+
+    def unexport
+      File.open(File.join(@gpio_directory, "unexport"), "w") { |file| file.write(@pin_number) }
+    end
+
+    def direction=(direction)
+      File.open(File.join(@gpio_directory, "gpio#{@pin_number}", "direction"), "w") { |file| file.write(direction) }
+    end
+
+    def direction
+      # Using this instead of simple "File.open(file_path).read" in order to close file after reading.
+      direction = nil
+      File.open(File.join(@gpio_directory, "gpio#{@pin_number}", "direction"), "r") { |file| direction = file.read.strip }
+      direction
+    end
+
+    def value=(value)
+      File.open(File.join(@gpio_directory, "gpio#{@pin_number}", "value"), "w") { |file| file.write(value) }
+    end
+
+    def value
+      # Using this instead of simple "File.open(file_path).read" in order to close file after reading.
+      value = nil
+      File.open(File.join(@gpio_directory, "gpio#{@pin_number}", "value"), "r") { |file| value = file.read.strip.to_i }
+      value
+    end
+
+  end
+end

data/lib/object_oriented_beaglebone_black/io.rb

@@ -0,0 +1,34 @@
+require 'fileutils'
+
+module ObjectOrientedBeagleboneBlack
+  module IO
+
+    def file_directory_path
+      raise "#{__method__} method must be implemented in the class including this module"
+    end
+
+    def write_to_io_file(filename, value)
+      FileUtils.mkdir_p(file_directory_path, mode: 0700) unless Dir.exists?(file_directory_path)
+      file_path = File.join(file_directory_path, filename)
+      
+      File.open(file_path, "w") do |file|
+        file.write(value) 
+      end
+    end
+
+    def read_from_io_file(filename)
+      file_path = File.join(file_directory_path, filename)
+
+      if File.exists?(file_path)
+        file_content = nil
+        # Using this instead of simple "File.open(file_path).read" in order to close file after reading. 
+        File.open(file_path) do |file|
+          file_content = file.read.strip
+        end
+        file_content
+      end
+
+    end
+
+  end
+end

data/lib/object_oriented_beaglebone_black/io/direction.rb

@@ -0,0 +1,10 @@
+module ObjectOrientedBeagleboneBlack
+  module IO
+    module Direction
+
+      IN = "in"
+      OUT = "out"
+
+    end
+  end
+end

data/lib/object_oriented_beaglebone_black/io/value.rb

@@ -0,0 +1,10 @@
+module ObjectOrientedBeagleboneBlack
+  module IO
+    module Value
+
+      HIGH = 1
+      LOW = 0
+
+    end
+  end
+end

data/lib/object_oriented_beaglebone_black/led.rb

@@ -0,0 +1,43 @@
+module ObjectOrientedBeagleboneBlack
+  class Led
+    include ObjectOrientedBeagleboneBlack::PinMappings
+    include ObjectOrientedBeagleboneBlack::IO
+
+    LED_RELATIVE_DIRECTORY_PATTERN = "leds/beaglebone:green:%s"
+    TRIGGER_FILENAME = "trigger"
+    GPIO_FILENAME = "brightness"
+
+    def initialize(led_name)
+      @led_name = led_name
+    end
+
+    def pin_mode=(pin_mode)
+      case pin_mode
+      when "out"
+        write_to_io_file(TRIGGER_FILENAME, "gpio")
+      else
+        raise "Invalid pin_mode for Led: #{pin_mode}. Must be 'out'"
+      end
+    end
+
+    def digital_write(state)
+      write_to_io_file(GPIO_FILENAME, state)
+    end
+
+    def state
+      state = read_from_io_file(GPIO_FILENAME)
+      begin
+        state.to_i
+      rescue
+        state
+      end
+    end
+
+    private
+      def file_directory_path
+        internal_led_name = property_hash(name: @led_name)["led"]
+        File.expand_path(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["io_root_directory"], sprintf(LED_RELATIVE_DIRECTORY_PATTERN, internal_led_name)))
+      end
+
+  end
+end

data/lib/object_oriented_beaglebone_black/pin_mappings.rb

@@ -0,0 +1,25 @@
+require 'json'
+# require 'active_support/core_ext/hash/keys'
+
+module ObjectOrientedBeagleboneBlack
+  module PinMappings
+    
+    def load_pin_index_array
+      # In order not to use activesupport (since Beaglebone Black that is used currently doesn't have Internet access to download it), Hash#deep_symbolize_keys! is not used.
+      # ::OBJECT_ORIENTED_BEAGLEBONE_BLACK_PIN_INDEX_ARRAY ||= JSON.load(File.read(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_ROOT, "config", "pin_index.json")))["pinIndex"].each { |property_hash| property_hash.deep_symbolize_keys! }
+      ::OBJECT_ORIENTED_BEAGLEBONE_BLACK_PIN_INDEX_ARRAY ||= JSON.load(File.read(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_ROOT, "config", "pin_index.json")))["pinIndex"]
+    end
+
+    def property_hash(name: nil, key: nil)
+      load_pin_index_array
+
+      if !name.nil?
+        ::OBJECT_ORIENTED_BEAGLEBONE_BLACK_PIN_INDEX_ARRAY.select { |property_hash| property_hash["name"] == name }.first
+      elsif !key.nil?
+        ::OBJECT_ORIENTED_BEAGLEBONE_BLACK_PIN_INDEX_ARRAY.select { |property_hash| property_hash["key"] == key }.first
+      end
+
+    end
+
+  end
+end

data/lib/object_oriented_beaglebone_black/pwm.rb

@@ -0,0 +1,58 @@
+require 'bigdecimal'
+
+module ObjectOrientedBeagleboneBlack
+  class Pwm
+
+    module Polarity
+      DIRECT = 0
+      INVERSE = 1
+    end    
+
+    DUTY_VALUE_PER_ONE_HUNDREDTH = BigDecimal("5000")
+
+    def initialize(pin_key)
+      @pin_key = pin_key
+      @slots_file_path = File.join(File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["slots_directory"], "slots"))
+
+      activate_device_tree_overlays
+    end
+
+    def activate_device_tree_overlays
+      # Note: Since slots file acts as an interface to activate Device Tree Overlay, simply writing to it does what needs to be done. 
+      #       I'm using appending here so that testing in a local environment becomes straightfoward. 
+      File.open(@slots_file_path, "a") { |file| file.write("am33xx_pwm") }
+      File.open(@slots_file_path, "a") { |file| file.write("bone_pwm_#{@pin_key}") }
+    end
+
+    # duty_cycle (value between 0 and 1)
+    def duty_cycle=(duty_cycle)
+      self.polarity = ObjectOrientedBeagleboneBlack::Pwm::Polarity::DIRECT
+      internal_duty_value = (BigDecimal(duty_cycle.to_s) * BigDecimal("100") * DUTY_VALUE_PER_ONE_HUNDREDTH).to_i
+      File.open(File.join(pwm_directory, "duty"), "w") { |file| file.write(internal_duty_value) }
+    end
+
+    def duty_cycle
+      # Using this instead of simple "File.open(file_path).read" in order to close file after reading.
+      internal_duty_value = nil
+      File.open(File.join(pwm_directory, "duty"), "r") { |file| internal_duty_value = file.read.strip }
+      duty_cycle = (BigDecimal(internal_duty_value.to_s) / DUTY_VALUE_PER_ONE_HUNDREDTH / BigDecimal("100")).to_f
+      duty_cycle
+    end
+
+    def polarity=(polarity)
+      File.open(File.join(pwm_directory, "polarity"), "w") { |file| file.write(polarity) }
+    end
+
+    def polarity
+      internal_polarity_value = nil
+      File.open(File.join(pwm_directory, "polarity"), "r") { |file| internal_polarity_value = file.read.strip.to_i }
+      internal_polarity_value
+    end
+
+    private
+      def pwm_directory
+        Dir["#{File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["device_directory"], "pwm_test_#{@pin_key}.")}*"].first
+      end    
+
+  end
+end

data/lib/object_oriented_beaglebone_black/version.rb

@@ -0,0 +1,3 @@
+module ObjectOrientedBeagleboneBlack
+  VERSION = "0.0.1"
+end

data/object_orieted_beaglebone_black.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'object_oriented_beaglebone_black/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "object_oriented_beaglebone_black"
+  spec.version       = ObjectOrientedBeagleboneBlack::VERSION
+  spec.authors       = ["Tadatoshi Takahashi"]
+  spec.email         = ["tadatoshi@gmail.com"]
+  spec.summary       = %q{For using BeagleBone Black in Object-Oriented way through Ruby.}
+  spec.description   = %q{Performs accessing GPIO, etc. in Object-Oriented way on BeagleBone Black through Ruby.}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+  spec.required_ruby_version = '>= 2.1.2'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib", "examples"]
+
+  # spec.add_dependency "activesupport"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+end

data/spec/examples/current_measurement/current_input_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+require 'current_measurement'
+require 'bigdecimal'
+
+describe "Current measurement by ACS712 Breakout", analog_input: true do
+
+  before(:each) do
+
+    @slots_directory = OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["slots_directory"]
+    @device_directory = OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["device_directory"]
+
+    # In order to run this spec example in the real environment, the directories and files that already exist there are not created in that case. 
+    if ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"] == 'test'
+      FileUtils.mkdir_p(@slots_directory, mode: 0700) unless Dir.exists?(@slots_directory)
+      FileUtils.touch(File.join(@slots_directory, "slots"))
+      File.chmod(0700, File.join(@slots_directory, "slots"))
+
+      FileUtils.mkdir_p(@device_directory, mode: 0700) unless Dir.exists?(@device_directory)         
+    end
+  end
+
+  after(:each) do
+    if ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"] == 'test'
+      File.open(File.join(@slots_directory, "slots"), 'w') {|file| file.truncate(0) }
+    end
+  end
+
+  it "should calculated the measured current" do
+
+    pin_key = "P9_40"
+    expected_current = BigDecimal("10").to_f
+    expected_raw_value = (BigDecimal(expected_current.to_s) * BigDecimal("0.185")).to_f
+
+    current_input = CurrentMeasurement::CurrentInput.new(pin_key)
+
+    # Since the real "slots" file creates a directory structure when a device tree overlay is written to it, 
+    # in the "test" environment with a regular file, it is mimiced here.
+    mimic_internal_analog_input_directory_creation(pin_key, expected_raw_value) if ENV["OBJECT_ORIENTED_BEAGLEBONE_BLACK_ENV"] == 'test'
+
+    expect(Dir.exists?(Dir["#{File.join(OBJECT_ORIENTED_BEAGLEBONE_BLACK_CONFIG["device_directory"], "helper.")}*"].first)).to be true
+
+    expect(current_input.value).to eq(expected_current)
+
+  end  
+  
+end