beaglebone 1.0.4

data/lib/beaglebone/i2c.rb

@@ -0,0 +1,186 @@
+module Beaglebone
+
+  module I2C
+
+    I2C_SLAVE = 0x0703
+
+    @i2cstatus = {}
+    @i2cmutex = Mutex.new
+
+    class << self
+      attr_accessor :i2cstatus, :i2cmutex
+
+      def write(i2c, address, data)
+        check_i2c_enabled(i2c)
+
+        lock_i2c(i2c) do
+          i2c_fd = get_i2c_status(i2c, :fd_i2c)
+
+          #set the slave address to communicate with
+          i2c_fd.ioctl(I2C_SLAVE, address)
+
+          i2c_fd.syswrite(data)
+        end
+
+      end
+
+      def read(i2c, address, bytes=1, register=nil)
+        check_i2c_enabled(i2c)
+
+        data = ''
+        lock_i2c(i2c) do
+          i2c_fd = get_i2c_status(i2c, :fd_i2c)
+
+          #set the slave address to communicate with
+          i2c_fd.ioctl(I2C_SLAVE, address)
+
+          i2c_fd.syswrite(register) if register
+
+          data = i2c_fd.sysread(bytes)
+        end
+
+        data
+      end
+
+      def file(i2c)
+        check_i2c_enabled(i2c)
+        get_i2c_status(i2c, :fd_i2c)
+      end
+
+      def setup(i2c)
+        check_i2c_valid(i2c)
+
+        #make sure i2c not already enabled
+        return if get_i2c_status(i2c)
+
+        i2cinfo = I2CS[i2c]
+
+        #ensure dtb is loaded
+        Beaglebone::device_tree_load("#{i2cinfo[:devicetree]}") if i2cinfo[:devicetree]
+
+        #open the i2c device
+        i2c_fd = File.open(i2cinfo[:dev], 'r+')
+
+        Beaglebone::set_pin_status(i2cinfo[:scl], :i2c, i2cinfo[:id])
+        Beaglebone::set_pin_status(i2cinfo[:scl], :type, :i2c)
+        Beaglebone::set_pin_status(i2cinfo[:scl], :fd_i2c, i2c_fd)
+
+        Beaglebone::set_pin_status(i2cinfo[:sda], :i2c, i2cinfo[:id])
+        Beaglebone::set_pin_status(i2cinfo[:sda], :type, :i2c)
+        Beaglebone::set_pin_status(i2cinfo[:sda], :fd_i2c, i2c_fd)
+
+        set_i2c_status(i2c, :fd_i2c, i2c_fd)
+        set_i2c_status(i2c, :mutex, Mutex.new)
+      end
+
+      def disable(i2c)
+        check_i2c_valid(i2c)
+        check_i2c_enabled(i2c)
+
+        disable_i2c_pin(I2CS[i2c][:sda]) if I2CS[i2c][:sda]
+        disable_i2c_pin(I2CS[i2c][:scl]) if I2CS[i2c][:scl]
+
+        delete_i2c_status(i2c)
+
+        #removing i2c tree causes a crash... can't really disable.
+        #Beaglebone::device_tree_unload("#{I2CS[i2c][:devicetree]}") if I2CS[i2c][:devicetree]
+
+      end
+
+      def cleanup
+        #reset all i2cs we've used and unload the device tree
+        i2cstatus.clone.keys.each { |i2c| disable(i2c)}
+      end
+
+      private
+
+      def disable_i2c_pin(pin)
+        Beaglebone::check_valid_pin(pin, :i2c)
+
+        Beaglebone::delete_pin_status(pin)
+      end
+
+      def check_i2c_valid(i2c)
+        raise ArgumentError, "Invalid i2c Specified #{i2c.to_s}" unless I2CS[i2c] && I2CS[i2c][:sda]
+        i2cinfo = I2CS[i2c.to_sym.upcase]
+
+        unless i2cinfo[:scl] && [nil,:i2c].include?(Beaglebone::get_pin_status(i2cinfo[:scl], :type))
+          raise StandardError, "SCL Pin for #{i2c.to_s} in use"
+        end
+
+        unless i2cinfo[:sda] && [nil,:i2c].include?(Beaglebone::get_pin_status(i2cinfo[:sda], :type))
+          raise StandardError, "SDA Pin for #{i2c.to_s} in use"
+        end
+
+      end
+
+      def check_i2c_enabled(i2c)
+        raise ArgumentError, "i2c not enabled #{i2c.to_s}" unless get_i2c_status(i2c)
+      end
+
+      def lock_i2c(i2c)
+        check_i2c_enabled(i2c)
+        mutex = get_i2c_status(i2c, :mutex)
+
+        mutex.synchronize do
+          yield
+        end
+      end
+
+      def get_i2c_status(i2c, key = nil)
+        i2cmutex.synchronize do
+          if key
+            i2cstatus[i2c] ? i2cstatus[i2c][key] : nil
+          else
+            i2cstatus[i2c]
+          end
+        end
+      end
+
+      def set_i2c_status(i2c, key, value)
+        i2cmutex.synchronize do
+          i2cstatus[i2c]    ||= {}
+          i2cstatus[i2c][key] = value
+        end
+      end
+
+      def delete_i2c_status(i2c, key = nil)
+        i2cmutex.synchronize do
+          if key.nil?
+            i2cstatus.delete(i2c)
+          else
+            i2cstatus[i2c].delete(key) if i2cstatus[i2c]
+          end
+        end
+      end
+
+    end
+  end
+
+  #oo interface
+  class I2CDevice
+
+    def initialize(i2c)
+      @i2c = i2c
+      I2C::setup(@i2c)
+    end
+
+    def read(address, bytes=1, register=nil)
+      I2C::read(@i2c, address, bytes, register)
+    end
+
+    def write(address, data)
+      I2C::write(@i2c, address, data)
+    end
+
+    def disable
+      I2C::disable(@i2c)
+    end
+
+    def file
+      I2C::file(@i2c)
+    end
+
+  end
+
+end

data/lib/beaglebone/pwm.rb

@@ -0,0 +1,479 @@
+# == pwm.rb
+# This file contains the PWM control methods
+module Beaglebone #:nodoc:
+  # AIN
+  # procedural methods for PWM control
+  # == Summary
+  # #start is called to enable a PWM pin
+  module PWM
+
+    # Polarity hash
+    POLARITIES = { :NORMAL => 0, :INVERTED => 1 }
+
+    class << self
+
+      # Initialize a PWM pin
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param duty should specify the duty cycle
+      # @param frequency should specify cycles per second
+      # @param polarity optional, should specify the polarity, :NORMAL or :INVERTED
+      # @param run optional, if false, pin will be configured but will not run
+      #
+      # @example
+      #   PWM.start(:P9_14, 90, 10, :NORMAL)
+      def start(pin, duty=nil, frequency=nil, polarity=nil, run=true)
+        #make sure the pwm controller dtb is loaded
+        Beaglebone::device_tree_load(TREES[:PWM][:global])
+
+        Beaglebone::check_valid_pin(pin, :pwm)
+
+        #if pin is enabled for something else, disable it
+        if Beaglebone::get_pin_status(pin) && Beaglebone::get_pin_status(pin, :type) != :pwm
+          Beaglebone::disable_pin(pin)
+        end
+
+        #load device tree for pin if not already loaded
+        unless Beaglebone::get_pin_status(pin, :type) == :pwm
+          Beaglebone::device_tree_load("#{TREES[:PWM][:pin]}#{pin}")
+          Beaglebone::set_pin_status(pin, :type, :pwm)
+        end
+
+        duty_fd = File.open("#{pwm_directory(pin)}/duty", 'r+')
+        period_fd = File.open("#{pwm_directory(pin)}/period", 'r+')
+        polarity_fd = File.open("#{pwm_directory(pin)}/polarity", 'r+')
+        run_fd = File.open("#{pwm_directory(pin)}/run", 'r+')
+
+        Beaglebone::set_pin_status(pin, :fd_duty, duty_fd)
+        Beaglebone::set_pin_status(pin, :fd_period, period_fd)
+        Beaglebone::set_pin_status(pin, :fd_polarity, polarity_fd)
+        Beaglebone::set_pin_status(pin, :fd_run, run_fd)
+
+
+        read_period_value(pin)
+        read_duty_value(pin)
+        read_polarity_value(pin)
+
+        run_fd.write('0')
+        run_fd.flush
+
+        set_polarity(pin, polarity) if polarity
+        set_frequency(pin, frequency) if frequency
+        set_duty_cycle(pin, duty) if duty
+
+        if run
+          run_fd.write('1')
+          run_fd.flush
+        end
+
+        raise StandardError, "Could not start PWM: #{pin}" unless read_run_value(pin) == 1
+        true
+      end
+
+      # Returns true if specified pin is enabled in PWM mode, else false
+      def enabled?(pin)
+        return true if Beaglebone::get_pin_status(pin, :type) == :pwm
+
+        return false unless valid?(pin)
+        if Dir.exists?(pwm_directory(pin))
+
+          start(pin, nil, nil, nil, false)
+          return true
+        end
+        false
+      end
+
+      # Stop PWM output on specified pin
+      #
+      # @param pin should be a symbol representing the header pin
+      def stop(pin)
+        Beaglebone::check_valid_pin(pin, :pwm)
+
+        return false unless enabled?(pin)
+
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless Beaglebone::get_pin_status(pin, :type) == :pwm
+
+        run_fd = Beaglebone::get_pin_status(pin, :fd_run)
+
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless run_fd
+
+        run_fd.write('0')
+        run_fd.flush
+
+        raise StandardError, "Could not stop PWM: #{pin}" unless read_run_value(pin) == 0
+        true
+      end
+
+      # Start PWM output on specified pin.  Pin must have been previously started
+      #
+      # @param pin should be a symbol representing the header pin
+      def run(pin)
+        Beaglebone::check_valid_pin(pin, :pwm)
+
+        return false unless enabled?(pin)
+
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless Beaglebone::get_pin_status(pin, :type) == :pwm
+
+        run_fd = Beaglebone::get_pin_status(pin, :fd_run)
+
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless run_fd
+
+        run_fd.write('1')
+        run_fd.flush
+
+        raise StandardError, "Could not start PWM: #{pin}" unless read_run_value(pin) == 1
+        true
+
+      end
+
+      # Set polarity on specified pin
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param polarity should specify the polarity, :NORMAL or :INVERTED
+      # @example
+      #   PWM.set_polarity(:P9_14, :INVERTED)
+      def set_polarity(pin, polarity)
+        check_valid_polarity(polarity)
+        check_pwm_enabled(pin)
+
+        polarity_fd = Beaglebone::get_pin_status(pin, :fd_polarity)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless polarity_fd
+
+        polarity_fd.write(POLARITIES[polarity.to_sym].to_s)
+        polarity_fd.flush
+
+        raise StandardError, "Could not set polarity: #{pin}" unless read_polarity_value(pin) == POLARITIES[polarity.to_sym]
+
+      end
+
+      # Set duty cycle of specified pin in percentage
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param duty should specify the duty cycle in percentage
+      # @example
+      #   PWM.set_duty_cycle(:P9_14, 25)
+      def set_duty_cycle(pin, duty, newperiod=nil)
+
+        raise ArgumentError, "Duty cycle must be >= 0 and <= 100, #{duty} invalid" if duty < 0 || duty > 100
+        check_pwm_enabled(pin)
+
+
+        fd = Beaglebone::get_pin_status(pin, :fd_duty)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        period = newperiod || Beaglebone::get_pin_status(pin, :period)
+
+        value = ((duty * period) / 100).to_i
+
+        fd.write(value.to_s)
+        fd.flush
+
+        raise StandardError, "Could not set duty cycle: #{pin} (#{value})" unless read_duty_value(pin) == value
+
+        value
+
+      end
+
+
+      # Set duty cycle of specified pin in nanoseconds
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param duty should specify the duty cycle in nanoseconds
+      # @example
+      #   PWM.set_duty_cycle_ns(:P9_14, 2500000)
+      def set_duty_cycle_ns(pin, duty)
+
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_duty)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        period = Beaglebone::get_pin_status(pin, :period)
+
+        duty = duty.to_i
+
+        if duty < 0 || duty > period
+          raise ArgumentError, "Duty cycle ns must be >= 0 and <= #{period} (current period), #{duty} invalid"
+        end
+
+        value = duty
+
+        fd.write(value.to_s)
+        fd.flush
+
+        raise StandardError, "Could not set duty cycle: #{pin} (#{value})" unless read_duty_value(pin) == value
+
+        value
+      end
+
+      # Set frequency of specified pin in cycles per second
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param frequency should specify the frequency in cycles per second
+      # @example
+      #   PWM.set_frequency(:P9_14, 100)
+      def set_frequency(pin, frequency)
+        frequency = frequency.to_i
+        raise ArgumentError, "Frequency must be > 0 and <= 1000000000, #{frequency} invalid" if frequency < 1 || frequency > 1000000000
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_period)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        duty_ns = Beaglebone::get_pin_status(pin, :duty)
+        duty_pct = Beaglebone::get_pin_status(pin, :duty_pct)
+
+        value = (1000000000 / frequency).to_i
+
+        #we can't set the frequency lower than the previous duty cycle
+        #adjust if necessary
+        if duty_ns > value
+          set_duty_cycle(pin, Beaglebone::get_pin_status(pin, :duty_pct), value)
+        end
+
+        fd.write(value.to_s)
+        fd.flush
+
+        raise StandardError, "Could not set frequency: #{pin} (#{value})" unless read_period_value(pin) == value
+
+        #adjust the duty cycle if we haven't already
+        if duty_ns <= value
+          set_duty_cycle(pin, duty_pct, value)
+        end
+
+        value
+      end
+
+      # Set frequency of specified pin based on period duration
+      #
+      # @param pin should be a symbol representing the header pin
+      # @param period should specify the length of a cycle in nanoseconds
+      #
+      # @example
+      #   PWM.set_frequency_ns(:P9_14, 100000000)
+      def set_period_ns(pin, period)
+        period = period.to_i
+        raise ArgumentError, "period must be > 0 and <= 1000000000, #{period} invalid" if period < 1 || period > 1000000000
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_period)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        duty_ns = Beaglebone::get_pin_status(pin, :duty)
+        value = period.to_i
+
+        #we can't set the frequency lower than the previous duty cycle
+        #adjust if necessary
+        if duty_ns > value
+          set_duty_cycle(pin, Beaglebone::get_pin_status(pin, :duty_pct), value)
+        end
+
+        fd.write(value.to_s)
+        fd.flush
+
+        raise StandardError, "Could not set period: #{pin} (#{value})" unless read_period_value(pin) == value
+
+        #adjust the duty cycle if we haven't already
+        if duty_ns <= value
+          set_duty_cycle(pin, Beaglebone::get_pin_status(pin, :duty_pct), value)
+        end
+
+        value
+      end
+
+      #reset all PWM pins we've used to IN and unexport them
+      def cleanup
+        get_pwm_pins.each { |x| disable_pwm_pin(x) }
+      end
+
+      # Return an array of PWM pins in use
+      #
+      # @return [Array<Symbol>]
+      #
+      # @example
+      #   PWM.get_pwm_pins => [:P9_13, :P9_14]
+      def get_pwm_pins
+        Beaglebone.pinstatus.clone.select { |x,y| x if y[:type] == :pwm}.keys
+      end
+
+      # Disable a PWM pin
+      #
+      # @param pin should be a symbol representing the header pin
+      def disable_pwm_pin(pin)
+        Beaglebone::check_valid_pin(pin, :pwm)
+        Beaglebone::delete_pin_status(pin) if Beaglebone::device_tree_unload("#{TREES[:PWM][:pin]}#{pin}")
+      end
+
+      private
+
+      #ensure pin is valid pwm pin
+      def valid?(pin)
+        #check to see if pin exists
+        pin = pin.to_sym.upcase
+
+        return false unless PINS[pin]
+        return false unless PINS[pin][:pwm]
+
+        true
+      end
+
+      #ensure pin is pwm enabled
+      def check_pwm_enabled(pin)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless enabled?(pin)
+      end
+
+      #read run file
+      def read_run_value(pin)
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_run)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        fd.rewind
+        fd.read.strip.to_i
+      end
+
+      #read polarity file
+      def read_polarity_value(pin)
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_polarity)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        fd.rewind
+        value = fd.read.strip.to_i
+
+        Beaglebone::set_pin_status(pin, :polarity, value)
+
+      end
+
+      #read duty file
+      def read_duty_value(pin)
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_duty)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        fd.rewind
+        value = fd.read.strip.to_i
+
+        Beaglebone::set_pin_status(pin, :duty, value)
+        Beaglebone::set_pin_status(pin, :duty_pct, ((value * 100) / Beaglebone::get_pin_status(pin, :period).to_i))
+
+        value
+      end
+
+      #read period file
+      def read_period_value(pin)
+        check_pwm_enabled(pin)
+
+        fd = Beaglebone::get_pin_status(pin, :fd_period)
+        raise StandardError, "Pin is not PWM enabled: #{pin}" unless fd
+
+        fd.rewind
+        value = fd.read.strip.to_i
+
+        Beaglebone::set_pin_status(pin, :period, value)
+        Beaglebone::set_pin_status(pin, :duty_pct, ((Beaglebone::get_pin_status(pin, :duty).to_i * 100) / value).to_i)
+
+        value
+      end
+
+      #return sysfs directory for pwm control
+      def pwm_directory(pin)
+        raise StandardError, 'Invalid Pin' unless valid?(pin)
+        Dir.glob("/sys/devices/ocp.*/pwm_test_#{pin}.*").first
+      end
+
+      #ensure polarity is valid
+      def check_valid_polarity(polarity)
+        #check to see if mode is valid
+        polarity = polarity.to_sym.upcase
+        raise ArgumentError, "No such polarity: #{polarity.to_s}" unless POLARITIES.include?(polarity)
+      end
+
+    end
+  end
+
+  # Object Oriented PWM Implementation.
+  # This treats the pin as an object.
+  class PWMPin
+
+    # Initialize a PWM pin
+    #
+    #
+    # @param duty should specify the duty cycle
+    # @param frequency should specify cycles per second
+    # @param polarity optional, should specify the polarity, :NORMAL or :INVERTED
+    # @param run optional, if false, pin will be configured but will not run
+    #
+    # @example
+    #   p9_14 = PWMPin.new(:P9_14, 90, 10, :NORMAL)
+    def initialize(pin, duty=nil, frequency=nil, polarity=nil, run=true)
+      @pin = pin
+      PWM::start(@pin, duty, frequency, polarity, run)
+    end
+
+    # Stop PWM output on pin
+    def stop
+      PWM::stop(@pin)
+    end
+
+    # Start PWM output on pin.  Pin must have been previously started
+    def run
+      PWM::run(@pin)
+    end
+
+    # Set polarity on pin
+    #
+    # @param polarity should specify the polarity, :NORMAL or :INVERTED
+    # @example
+    #   p9_14.set_polarity(:INVERTED)
+    def set_polarity(polarity)
+      PWM::set_polarity(@pin, polarity)
+    end
+
+    # Set duty cycle of pin in percentage
+    #
+    #
+    # @param duty should specify the duty cycle in percentage
+    # @example
+    #   p9_14.set_duty_cycle(25)
+    def set_duty_cycle(duty, newperiod=nil)
+      PWM::set_duty_cycle(@pin, duty, newperiod)
+    end
+
+    # Set duty cycle of pin in nanoseconds
+    #
+    # @param duty should specify the duty cycle in nanoseconds
+    # @example
+    #   p9_14.set_duty_cycle_ns(2500000)
+    def set_duty_cycle_ns(duty)
+      PWM::set_duty_cycle_ns(@pin, duty)
+    end
+
+    # Set frequency of pin in cycles per second
+    #
+    # @param frequency should specify the frequency in cycles per second
+    # @example
+    #   p9_14.set_frequency(100)
+    def set_frequency(frequency)
+      PWM::set_frequency(@pin, frequency)
+    end
+
+    # Set frequency of pin based on period duration
+    #
+    # @param period should specify the length of a cycle in nanoseconds
+    # @example
+    #   p9_14.set_frequency_ns(100000000)
+    def set_period_ns(period)
+      PWM::set_period_ns(@pin, period)
+    end
+
+    # Disable PWM pin
+    def disable_pwm_pin
+      PWM::disable_pwm_pin(@pin)
+    end
+  end
+
+end

data/lib/beaglebone/shiftregister.rb

@@ -0,0 +1,21 @@
+module Beaglebone
+  class ShiftRegister
+
+    def initialize(latch_pin, clock_pin, data_pin, lsb=nil)
+
+      @latch_pin = latch_pin
+      @clock_pin = clock_pin
+      @data_pin  = data_pin
+      @lsb       = lsb
+
+      GPIO::pin_mode(@latch_pin, :OUT)
+      GPIO::pin_mode(@clock_pin, :OUT)
+      GPIO::pin_mode(@data_pin, :OUT)
+    end
+
+    def shiftout(data, lsb=nil)
+      GPIO::shift_out(@latch_pin, @clock_pin, @data_pin, data, lsb || @lsb)
+    end
+
+  end
+end