lgpio 0.1.4 → 0.1.6

data/lib/lgpio/hardware_pwm.rb

@@ -0,0 +1,83 @@
+module LGPIO
+  class HardwarePWM
+    NS_PER_S  = 1_000_000_000
+    NS_PER_US = 1_000
+    SYS_FS_PWM_PATH = "/sys/class/pwm/"
+
+    attr_reader :period, :duty, :enabled
+
+    def initialize(chip, channel, frequency: nil, period: nil)
+      @chip    = chip
+      @channel = channel
+
+      # Accept either frequency (in Hz) or period in nanoseconds.
+      if (frequency && period) || (!frequency && !period)
+        raise "either period: or frequency: is required, but not both"
+      end
+
+      period ? self.period = period : self.frequency = frequency
+      enable
+    end
+
+    def path
+      @path ||= "#{SYS_FS_PWM_PATH}pwmchip#{@chip}/pwm#{@channel}/"
+    end
+
+    def period_path
+      @period_path ||= "#{path}period"
+    end
+
+    def duty_path
+      @duty_path ||= "#{path}duty_cycle"
+    end
+
+    def enable_path
+      @enable_path ||= "#{path}enable"
+    end
+
+    def frequency=(freq)
+      self.period = (NS_PER_S / freq.to_f).round
+    end
+
+    def period=(p)
+      old_period = File.read("#{path}period").strip.to_i
+      unless (old_period == 0)
+        File.open(duty_path, 'w') { |f| f.write("0") }
+      end
+      File.open(period_path, 'w') { |f| f.write(p) }
+      @period = p
+    end
+
+    def duty_percent
+      return 0.0 if (!duty || !period) || (duty == 0)
+      (duty / period.to_f) * 100.0
+    end
+
+    def duty_percent=(d)
+      raise "duty_cycle: #{d} % cannot be more than 100%" if d > 100
+      d_ns = ((d / 100.0) * @period.to_i).round
+      self.duty = d_ns
+    end
+
+    def duty_us=(d_us)
+      d_ns = (d_us * NS_PER_US).round
+      self.duty = d_ns
+    end
+
+    def duty=(d_ns)
+      raise "duty cycle: #{d_ns} ns cannot be longer than period: #{period} ns" if d_ns > period
+      File.open(duty_path, 'w') { |f| f.write(d_ns) }
+      @duty = d_ns
+    end
+
+    def disable
+      File.open(enable_path, 'w') { |f| f.write("0") }
+      @enabled = false
+    end
+
+    def enable
+      File.open(enable_path, 'w') { |f| f.write("1") }
+      @enabled = true
+    end
+  end
+end

data/lib/lgpio/i2c_bitbang.rb

@@ -0,0 +1,117 @@
+module LGPIO
+  class I2CBitBang
+    VALID_ADDRESSES = (0x08..0x77).to_a
+
+    attr_reader :handle, :scl, :sda
+
+    def initialize(handle, scl, sda)
+      @handle = handle
+      @scl    = scl
+      @sda    = sda
+      @sda_state = nil
+      initialize_pins
+    end
+
+    def initialize_pins
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_PULL_NONE, scl, LGPIO::HIGH)
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, sda, LGPIO::HIGH)
+    end
+
+    def set_sda(value)
+      return if (@sda_state == value)
+      LGPIO.gpio_write(handle, sda, @sda_state = value)
+    end
+
+    def write_form(address)
+      (address << 1)
+    end
+
+    def read_form(address)
+      (address << 1) | 0b00000001
+    end
+
+    def start
+      LGPIO.gpio_write(handle, sda, 0)
+      LGPIO.gpio_write(handle, scl, 0)
+    end
+
+    def stop
+      LGPIO.gpio_write(handle, sda, 0)
+      LGPIO.gpio_write(handle, scl, 1)
+      LGPIO.gpio_write(handle, sda, 1)
+    end
+
+    def read_bit
+      set_sda(1)
+      LGPIO.gpio_write(handle, scl, 1)
+      bit = LGPIO.gpio_read(handle, sda)
+      LGPIO.gpio_write(handle, scl, 0)
+      bit
+    end
+
+    def write_bit(bit)
+      set_sda(bit)
+      LGPIO.gpio_write(handle, scl, 1)
+      LGPIO.gpio_write(handle, scl, 0)
+    end
+
+    def read_byte(ack)
+      byte = 0
+      i    = 0
+      while i < 8
+        byte = (byte << 1) | read_bit
+        i = i + 1
+      end
+      write_bit(ack ? 0 : 1)
+      byte
+    end
+
+    def write_byte(byte)
+      i = 7
+      while i >= 0
+        write_bit (byte >> i) & 0b1
+        i = i - 1
+      end
+      # Return ACK (SDA pulled low) or NACK (SDA stayed high).
+      (read_bit == 0)
+    end
+
+    def read(address, length)
+      raise ArgumentError, "invalid I2C address: #{address}. Range is 0x08..0x77" unless VALID_ADDRESSES.include?(address)
+      raise ArgumentError, "invalid Integer for read length: #{length}" unless length.kind_of?(Integer)
+
+      start
+      ack = write_byte(read_form(address))
+      return nil unless ack
+
+      # Read length bytes, and ACK for all but the last one.
+      bytes = []
+      (length-1).times { bytes << read_byte(true) }
+      bytes << read_byte(false)
+      stop
+
+      bytes
+    end
+
+    def write(address, bytes)
+      raise ArgumentError, "invalid I2C address: #{address}. Range is 0x08..0x77" unless VALID_ADDRESSES.include?(address)
+      raise ArgumentError, "invalid byte Array to write: #{bytes}" unless bytes.kind_of?(Array)
+
+      start
+      write_byte(write_form(address))
+      bytes.each { |byte| write_byte(byte) }
+      stop
+    end
+
+    def search
+      found = []
+      VALID_ADDRESSES.each do |address|
+        start
+        # Device present if ACK received when we write its address to the bus.
+        found << address if write_byte(write_form(address))
+        stop
+      end
+      found
+    end
+  end
+end

data/lib/lgpio/infrared.rb

@@ -0,0 +1,8 @@
+module LGPIO
+  class Infrared < HardwarePWM
+    def transmit(pulses, duty: 33.333)
+      self.duty_percent = duty
+      tx_wave_ook(duty_path, @duty.to_s, pulses)
+    end
+  end
+end

data/lib/lgpio/one_wire.rb

@@ -0,0 +1,171 @@
+module LGPIO
+  class OneWire
+    # Constants
+    READ_POWER_SUPPLY = 0xB4
+    CONVERT_T         = 0x44
+    SEARCH_ROM        = 0xF0
+    READ_ROM          = 0x33
+    SKIP_ROM          = 0xCC
+    MATCH_ROM         = 0x55
+    ALARM_SEARCH      = 0xEC
+    READ_SCRATCH      = 0xBE
+    WRITE_SCRATCH     = 0x4E
+    COPY_SCRATCH      = 0x48
+    RECALL_EEPROM     = 0xB8
+
+    attr_reader :handle, :gpio, :found_addresses
+
+    def initialize(handle, gpio)
+      @handle = handle
+      @gpio   = gpio
+      @found_addresses = []
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, gpio, LGPIO::HIGH)
+    end
+
+    def reset
+      # LGPIO.one_wire_reset returns 0 if device present on bus.
+      return (LGPIO.one_wire_reset(handle, gpio) == 0)
+    end
+
+    def read(byte_count)
+      read_bytes = []
+      byte_count.times do
+        byte = 0b00000000
+        8.times { |i| byte |= LGPIO.one_wire_bit_read(handle, gpio) << i }
+        read_bytes << byte
+      end
+      read_bytes
+    end
+
+    def write(byte_array, parasite: nil)
+      byte_array.each do |byte|
+        8.times { |i| LGPIO.one_wire_bit_write(handle, gpio, (byte >> i) & 0b1) }
+      end
+      # Drive bus high to feed parasite capacitor after write.
+      LGPIO.gpio_write(handle, gpio, LGPIO::HIGH) if parasite
+    end
+
+    def search
+      branch_mask      = 0
+      high_discrepancy = 0
+
+      loop do
+        reset
+        write [SEARCH_ROM]
+        result = search_pass(branch_mask)
+
+        address, high_discrepancy = parse_search_result(result)
+        @found_addresses << address
+
+        # No unsearched discrepancies left.
+        break if high_discrepancy == -1
+
+        # Force highest new discrepancy to be a 1 on the next search.
+        # i.e. Go as deep as possible into each branch found then back out.
+        #
+        branch_mask = branch_mask | (2 ** high_discrepancy)
+
+        # Clear bits above high_discrepancy so we don't repeat branches.
+        # When high_discrepancy < MSB of branch_mask, this moves us
+        # one node out, closer to the root, and finishing the search.
+        #
+        unset_mask = 0xFFFFFFFFFFFFFFFF >> (63 - high_discrepancy)
+        branch_mask = branch_mask & unset_mask
+      end
+    end
+
+    # Read a single 64-bit address and complement from the bus.
+    def search_pass(mask)
+      bytes = []
+
+      8.times do |i|
+        addr = 0
+        comp = 0
+        8.times do |j|
+          addr |= LGPIO.one_wire_bit_read(handle, gpio) << j
+          comp |= LGPIO.one_wire_bit_read(handle, gpio) << j
+
+          # A set (1) mask bit means we're searching a branch with that bit set.
+          # Force it to be 1 on this pass. Write 1 to both the bus and address bit.
+          #
+          # Don't change the complement bit from 0, Even if the bus said 0/0,
+          # send back 1/0, hiding known discrepancies, only sending new ones.
+          #
+          # Mask is a 64-bit number, not byte array.
+          if ((mask >> (i*8 + j)) & 0b1) == 1
+            LGPIO.one_wire_bit_write(handle, gpio, 1)
+            addr |= 1 << j
+
+          # Whether there was no "1-branch" marked for this bit, or there is no
+          # discrepancy at all, just echo address bit to the bus. We will
+          # compare addr/comp to find discrepancies for future passes.
+          else
+            LGPIO.one_wire_bit_write(handle, gpio, (addr >> j) & 0b1)
+          end
+        end
+        bytes << addr
+        bytes << comp
+      end
+
+      # 16 bytes, address and complement bytes interleaved LSByteFIRST.
+      # DON'T CHANGE! #split_search_result deals with it. denko uses #search_pass
+      # directly on Linux, but MCUs send it this format to save RAM. Always match it.
+      return bytes
+    end
+
+    def parse_search_result(result)
+      address, complement = split_search_result(result)
+
+      raise "OneWire device not connected, or disconnected during search" if (address & complement) > 0
+      raise "CRC error during OneWire search" unless OneWire.crc(address)
+
+      # Gives 0 at every discrepancy we didn't write 1 for on this pass.
+      new_discrepancies = address ^ complement
+
+      high_discrepancy = -1
+      (0..63).each { |i| high_discrepancy = i if new_discrepancies[i] == 0 }
+
+      [address, high_discrepancy]
+    end
+
+    # Convert interleaved address/complement bytes to 64-bit numbers.
+    def split_search_result(data)
+      address    = 0
+      complement = 0
+      data.reverse.each_slice(2) do |comp_byte, addr_byte|
+        address    = (address << 8)    | addr_byte
+        complement = (complement << 8) | comp_byte
+      end
+      [address, complement]
+    end
+
+    # CRC Class Methods
+    def self.crc(data)
+      calculated, received = self.calculate_crc(data)
+      calculated == received
+    end
+
+    def self.calculate_crc(data)
+      if data.class == Integer
+        bytes = address_to_bytes(data)
+      else
+        bytes = data
+      end
+
+      crc = 0b00000000
+      bytes.take(bytes.length - 1).each do |byte|
+        for bit in (0..7)
+          xor = byte[bit] ^ crc[0]
+          crc = crc ^ ((xor * (2 ** 3)) | (xor * (2 ** 4)))
+          crc = crc >> 1
+          crc = crc | (xor * (2 ** 7))
+        end
+      end
+      [crc, bytes.last]
+    end
+
+    def self.address_to_bytes(address)
+      [address].pack('Q<').split("").map(&:ord)
+    end
+  end
+end

data/lib/lgpio/positional_servo.rb

@@ -0,0 +1,28 @@
+module LGPIO
+  class PositionalServo < HardwarePWM
+    FREQUENCY = 50
+
+    attr_reader :angle
+
+    def initialize(chip, channel, min_us, max_us, min_angle, max_angle)
+      super(chip, channel, frequency: FREQUENCY)
+
+      raise "min_us: #{min_us} cannot be lower than max_us: #{max_us}" if max_us < min_us
+      @min_us = min_us
+      @max_us = max_us
+      @us_range = @max_us - @min_us
+
+      @min_angle = min_angle
+      @max_angle = max_angle
+    end
+
+    def angle=(a)
+      ratio = (a - @min_angle).to_f / (@max_angle - @min_angle)
+      raise "angle: #{a} outside servo range" if (ratio < 0) || (ratio > 1)
+
+      d_us = (@us_range * ratio) + @min_us
+      self.duty_us = d_us
+      @angle = a
+    end
+  end
+end

data/lib/lgpio/spi_bitbang.rb

@@ -0,0 +1,109 @@
+module LGPIO
+  class SPIBitBang
+    attr_reader :handle, :clock, :input, :output
+
+    def initialize(options={})
+      @handle = options[:handle]
+      @clock  = options[:clock]  || options[:sck]  || options[:clk]
+      @input  = options[:input]  || options[:poci] || options[:miso]
+      @output = options[:output] || options[:pico] || options[:mosi]
+
+      raise ArgumentError, "a gpiochip :handle is required" unless @handle
+      raise ArgumentError, "either input/:poci/:miso OR :output/:pico/:mosi pin required" unless (@input || @output)
+      raise ArgumentError, ":clock/:sck/:clk pin required" unless @clock
+
+      @output_state = nil
+      initialize_pins
+    end
+
+    def initialize_pins
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_PULL_NONE, clock, LGPIO::LOW)
+      LGPIO.gpio_claim_input(handle, LGPIO::SET_PULL_NONE, input) if input
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_PULL_NONE, output, LGPIO::LOW) if output
+    end
+
+    def set_output(level)
+      return if (level == @output_state)
+      LGPIO.gpio_write(handle, output, @output_state = level)
+    end
+
+    def transfer_bit(write_bit, reading: false, mode: 0)
+      case mode
+      when 0
+        set_output(write_bit) if write_bit
+        LGPIO.gpio_write(handle, clock, 1)
+        read_bit = LGPIO.gpio_read(handle, input) if reading
+        LGPIO.gpio_write(handle, clock, 0)
+      when 1
+        LGPIO.gpio_write(handle, clock, 1)
+        set_output(write_bit) if write_bit
+        LGPIO.gpio_write(handle, clock, 0)
+        read_bit = LGPIO.gpio_read(handle, input) if reading
+      when 2
+        set_output(write_bit) if write_bit
+        LGPIO.gpio_write(handle, clock, 0)
+        read_bit = LGPIO.gpio_read(handle, input) if reading
+        LGPIO.gpio_write(handle, clock, 1)
+      when 3
+        LGPIO.gpio_write(handle, clock, 0)
+        set_output(write_bit) if write_bit
+        LGPIO.gpio_write(handle, clock, 1)
+        read_bit = LGPIO.gpio_read(handle, input) if reading
+      else
+        raise ArgumentError, "invalid SPI mode: #{mode} given"
+      end
+      return reading ? read_bit : nil
+    end
+
+    def transfer_byte(byte, reading: false, order: :msbfirst, mode: 0)
+      read_byte = reading ? 0 : nil
+
+      if (order == :msbfirst)
+        i = 7
+        while i >= 0
+          write_bit = byte ? (byte >> i) & 0b1 : nil
+          read_bit  = transfer_bit(write_bit, mode: mode, reading: reading)
+          read_byte = (read_byte << 1) | read_bit if reading
+          i = i - 1
+        end
+      else
+        i = 0
+        while i < 8
+          write_bit = byte ? (byte >> i) : nil
+          read_bit  = transfer_bit(write_bit, mode: mode, reading: reading)
+          read_byte = read_byte | (read_bit << i) if reading
+          i = i + 1
+        end
+      end
+
+      read_byte
+    end
+
+    def transfer(write: [], read: 0, select: nil, order: :msbfirst, mode: 0)
+      # Idle clock state depends on SPI mode.
+      case mode
+      when 0..1
+        LGPIO.gpio_write(handle, clock, 0)
+      when 2..3
+        LGPIO.gpio_write(handle, clock, 1)
+      else
+        raise ArgumentError, "invalid SPI mode: #{mode} given"
+      end
+      raise ArgumentError, "invalid Array for write: #{write}" unless write.kind_of?(Array)
+      raise ArgumentError, "invalid Integer for read: #{read}" unless read.kind_of?(Integer)
+
+      read_bytes = (read > 0) ? [] : nil
+      LGPIO.gpio_write(handle, select, 0) if select
+
+      i = 0
+      while (i < read) || (i < write.length)
+        read_byte = transfer_byte(write[i], reading: (i < read), order: order, mode: mode)
+        read_bytes << read_byte if read_byte
+        i = i + 1
+      end
+
+      LGPIO.gpio_write(handle, select, 1) if select
+      read_bytes
+    end
+  end
+end

data/lib/lgpio/version.rb

@@ -1,3 +1,3 @@
 module LGPIO
-  VERSION = "0.1.4"
+  VERSION = "0.1.6"
 end

data/lib/lgpio.rb

@@ -1,4 +1,13 @@
 require_relative 'lgpio/lgpio'
+require_relative 'lgpio/version'
+
+require_relative 'lgpio/i2c_bitbang'
+require_relative 'lgpio/spi_bitbang'
+require_relative 'lgpio/one_wire'
+
+require_relative 'lgpio/hardware_pwm'
+require_relative 'lgpio/positional_servo'
+require_relative 'lgpio/infrared'
 
 module LGPIO
   LOW = 0

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.6
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-08-05 00:00:00.000000000 Z
+date: 2024-09-19 00:00:00.000000000 Z
 dependencies: []
 description: Use GPIO / PWM / I2C / SPI / UART on Linux SBCs in Ruby
 email: mail@vickash.com
@@ -24,18 +24,31 @@ files:
 - examples/bench_in.rb
 - examples/bench_out.rb
 - examples/blink.rb
+- examples/dht.rb
 - examples/group_in.rb
 - examples/group_out.rb
+- examples/hcsr04.rb
 - examples/i2c_aht10.rb
 - examples/i2c_aht10_zip.rb
+- examples/i2c_bitbang-rb_aht10.rb
+- examples/i2c_bitbang-rb_ssd1306_bench.rb
+- examples/i2c_bitbang_aht10.rb
+- examples/i2c_bitbang_search.rb
+- examples/i2c_bitbang_ssd1306_bench.rb
 - examples/i2c_ssd1306_bench.rb
+- examples/infrared.rb
 - examples/momentary.rb
+- examples/one_wire_ds18b20.rb
+- examples/one_wire_search.rb
 - examples/pwm.rb
 - examples/reports.rb
 - examples/rotary_encoder.rb
 - examples/rotary_encoder_led.rb
+- examples/servo.rb
+- examples/spi_bitbang_loopback.rb
+- examples/spi_bitbang_ssd1306_bench.rb
+- examples/spi_bitbang_ssd1306_sim_bench.rb
 - examples/spi_loopback.rb
-- examples/spi_read.rb
 - examples/spi_ws2812.rb
 - examples/spi_ws2812_bounce.rb
 - examples/wave.rb
@@ -43,6 +56,12 @@ files:
 - ext/lgpio/lgpio.c
 - lgpio.gemspec
 - lib/lgpio.rb
+- lib/lgpio/hardware_pwm.rb
+- lib/lgpio/i2c_bitbang.rb
+- lib/lgpio/infrared.rb
+- lib/lgpio/one_wire.rb
+- lib/lgpio/positional_servo.rb
+- lib/lgpio/spi_bitbang.rb
 - lib/lgpio/version.rb
 homepage: https://github.com/denko-rb/lgpio
 licenses:

data/examples/spi_read.rb

@@ -1,14 +0,0 @@
-require 'lgpio'
-
-SPI_DEV  = 1
-SPI_CHAN = 0
-SPI_MODE = 0
-SPI_BAUD = 1_000_000
-
-spi_handle = LGPIO.spi_open(SPI_DEV, SPI_CHAN, SPI_BAUD, SPI_MODE)
-
-# Pull MISO high or low. High gives array of 255, low array of 0.
-rx_bytes = LGPIO.spi_read(spi_handle, 8)
-puts "RX bytes: #{rx_bytes.inspect}"
-
-LGPIO.spi_close(spi_handle)