pi_driver 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: bc90f84fe49ba85fc4c6e0f5b3af5e6396952733
+  data.tar.gz: 30d3039abade3868c00a0872176b243452e3a39b
+SHA512:
+  metadata.gz: d7c63839480a43a98c4a26e7e9aa20bd4d5e196b697f2eb6db48098997ffb21e2f8fd97db4cff0e5cbe01c140d3837fa8f170bdcd1f986eb2d16ec42d25c4725
+  data.tar.gz: '0635499eee9f47a2479e2759d72399231bce35417ccac7a9d673c858d0c3bb93ed3e018482ece97be0fc04290164f64a363e5b90cdeb708a86e245f22143f582'

data/bin/pin.rb

@@ -0,0 +1,4 @@
+# ruby -Ilib ./bin/pin.rb 10
+
+require 'pi_driver'
+puts PiDriver::Pin.new(ARGV[0]).clear?

data/lib/pi_driver/i2c_master.rb

@@ -0,0 +1,106 @@
+module PiDriver
+  class I2CMaster
+    def initialize(options = {})
+      @frequency = 100_000
+      @delta_time = @frequency ** -1.0
+      @clock_pin = options[:clock_pin]
+      @data_pin = options[:data_pin]
+      @num_bits = 8
+      stop
+    end
+
+    def stop
+      release_clock_pin
+      release_data_pin
+    end
+
+    def start
+      drive_data_pin
+      drive_clock_pin
+    end
+
+    def write(byte)
+      send_data byte
+      byte
+    end
+
+    def read
+      release_data_pin
+      read_data
+    end
+
+    def ack
+      release_data_pin
+      release_clock_pin
+      success = @data_pin.clear?
+      drive_clock_pin
+      success
+    end
+
+    private
+
+    # def send_address(direction = :read)
+    #   byte = @slave_address << 1
+    #   byte += Pin::Value::HIGH if direction == :read
+    #   send_data byte
+    # end
+
+    def send_data(byte)
+      bits = byte_to_bits byte
+      bits.each do |bit|
+        bit == Pin::Value::HIGH ? release_data_pin : drive_data_pin
+        release_clock_pin
+        drive_clock_pin
+      end
+    end
+
+    def read_data
+      bits = []
+      @num_bits.times do
+        release_clock_pin
+        bits << @data_pin.value
+        drive_clock_pin
+      end
+      bits_to_byte(bits)
+    end
+
+    def byte_to_bits(byte)
+      byte.to_s(2).rjust(@num_bits, '0').chars.map(&:to_i)
+    end
+
+    def bits_to_byte(bits)
+      bits.join.to_i(2)
+    end
+
+    def release_data_pin
+      @data_pin.input
+      observe_speed_requirement
+    end
+
+    def drive_data_pin
+      @data_pin.output Pin::Value::LOW
+      observe_speed_requirement
+    end
+
+    def release_clock_pin
+      @clock_pin.input
+      observe_clock_stretch
+      observe_speed_requirement
+    end
+
+    def drive_clock_pin
+      @clock_pin.output Pin::Value::LOW
+      observe_speed_requirement
+    end
+
+    def observe_clock_stretch
+      # 1ms timeout typical
+      loop { break if @clock_pin.set?}
+    end
+
+    def observe_speed_requirement
+      start = Time.now
+      loop { break if (Time.now - start) > @delta_time }
+    end
+  end
+end

data/lib/pi_driver/pin.rb

@@ -0,0 +1,165 @@
+module PiDriver
+  class Pin
+    # delete this and below
+    DIR_BASE = File.expand_path '~/pi/gpio/sys/class'
+    # # uncomment below, delete this
+    # DIR_BASE = '/sys/class'
+
+    DIR_GPIO = "#{DIR_BASE}/gpio"
+
+    attr_reader :gpio_number
+
+    class Direction
+      INPUT = :in
+      OUTPUT = :out
+      VALID_DIRECTIONS = [INPUT, OUTPUT]
+    end
+
+    class Edge
+      RISING = :rising
+      FALLING = :falling
+      BOTH = :both
+      NONE = :none
+      VALID_EDGES = [RISING, FALLING, BOTH, NONE]
+    end
+
+    class Value
+      LOW = 0
+      HIGH = 1
+      VALID_VALUES = [LOW, HIGH]
+    end
+
+    def initialize(gpio_number, options = {})
+      direction = options[:direction] || Direction::INPUT
+      value = options[:value] || Value::LOW
+
+      write_export gpio_number
+
+      write_direction(direction)
+      input? ? read_value : write_value(value)
+    end
+
+    def input
+      write_direction(Direction::INPUT) unless input?
+    end
+
+    def input?
+      @direction == Direction::INPUT
+    end
+
+    def output(value = Value::LOW)
+      write_direction(Direction::OUTPUT) unless output?
+      write_value(value)
+    end
+
+    def output?
+      @direction == Direction::OUTPUT
+    end
+
+    def clear
+      return unless output?
+      write_value(Value::LOW) unless clear?
+      @value
+    end
+
+    def clear?
+      value == Value::LOW
+    end
+
+    def set
+      return unless output?
+      write_value(Value::HIGH) unless set?
+      @value
+    end
+
+    def set?
+      value == Value::HIGH
+    end
+
+    def value
+      input? ? read_value : @value
+    end
+
+    def interrupt(edge = Edge::RISING)
+      check_arg(:edge, edge, Edge::VALID_EDGES)
+
+      @edge = edge
+
+      @interrupt_thread = Thread.new do
+        last_value = read_value
+        loop do
+          new_value = read_value
+          yield if block_given? && interrupted?(new_value, last_value)
+          last_value = new_value
+        end
+      end
+    end
+
+    def clear_interrupt
+      @interrupt_thread.kill if @interrupt_thread
+    end
+
+    private
+
+    def check_arg(type, arg, valid_options)
+      valid_options_for_message = valid_options.map { |value| ":#{value}"}.join(', ')
+      message = "Pin #{@gpio_number} invalid #{type}: #{arg} expected to be one of #{valid_options_for_message}"
+      raise ArgumentError, message unless valid_options.include?(arg)
+    end
+
+    def dir_pin
+      "#{DIR_GPIO}/gpio#{@gpio_number}"
+    end
+
+    def interrupted?(new_value, last_value)
+      rising_edge = new_value == Value::HIGH && last_value == Value::LOW
+      falling_edge = new_value == Value::LOW && last_value == Value::HIGH
+
+      case @edge
+      when :rising
+        rising_edge
+      when :falling
+        falling_edge
+      when :both
+        rising_edge || falling_edge
+      end
+    end
+
+    def path_direction
+      "#{dir_pin}/direction"
+    end
+
+    def path_export
+      "#{DIR_GPIO}/export"
+    end
+
+    def path_value
+      "#{dir_pin}/value"
+    end
+
+    def read_direction
+      @direction = File.read(path_direction).to_sym
+    end
+
+    def read_value
+      @value = File.read(path_value).to_i
+    end
+
+    def write_direction(direction)
+      check_arg(:direction, direction, Direction::VALID_DIRECTIONS)
+      @direction = direction
+      File.write(path_direction, @direction)
+    end
+
+    def write_export(gpio_number)
+      @gpio_number = gpio_number
+      File.write(path_export, @gpio_number)
+    end
+
+    def write_value(value)
+      check_arg(:value, value, Value::VALID_VALUES)
+      @value = value
+      File.write(path_value, @value)
+    end
+  end
+end

data/lib/pi_driver.rb

@@ -0,0 +1,5 @@
+require 'pi_driver/pin'
+require 'pi_driver/i2c_master'
+
+module PiDriver
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification
+name: pi_driver
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Lucas Winningham
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2018-03-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby driver for Raspberry Pi
+email: lucas.winningham@gmail.com
+executables:
+- pin.rb
+extensions: []
+extra_rdoc_files: []
+files:
+- bin/pin.rb
+- lib/pi_driver.rb
+- lib/pi_driver/i2c_master.rb
+- lib/pi_driver/pin.rb
+homepage: http://rubygems.org/gems/pi_driver
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14
+signing_key: 
+specification_version: 4
+summary: Ruby driver for Raspberry Pi
+test_files: []