lgpio 0.1.8 → 0.1.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3007d43d8623a895efdcfb2089ccc3c9105bde952af5095d904019d2df56eaaf
-  data.tar.gz: 8aa7f8ecf78eff10e04deb2bc5a5732b939cbbaa99f7b4f578dd8320a7634fb7
+  metadata.gz: 4da526bc3f239adf23035ca2c8923463667f979038b01fe0f8b63f0ad017a0e1
+  data.tar.gz: 6beafa4839875a6aac25f78a0b4b3e4fa25a28569269254ec4dcea27bfc06572
 SHA512:
-  metadata.gz: 93cc1be6fcafd45e98a11272f608241adc2c809f0ff6d71333a63f93453bb34fba4a75155cb973c06407b6cea281fbdd934664970077a1608718f0f218eb49cd
-  data.tar.gz: f94f8859d0b7c3999687263a54979472fd73df50c0a3e09319aeb908c3b4e7de1bac458d97478f0ddeba19e4fe10d061c57e9331fc6910f386101315f4d087d5
+  metadata.gz: af9365d7c43fc0f7d5bab7c360e5a2e9325f2c3f7b7015ffff39d98ee3c4c2041123dfb81354d5d0113a06daab31910d18ed3fcee91dd75ded80c13b87543cba
+  data.tar.gz: aef0e2f50840a3b601627283f15df63f1f6ab5d065288f05275c07d04e0ad32def28d055acedfbba807c16f16b041d2df3bd5444f093bbb55c604aac2026c4ac

data/README.md

@@ -43,16 +43,21 @@ These use the sysfs PWM interface, not lgpio C, but are a good fit for this gem.
 ## Installation
 On Debian-based Linuxes (RaspberryPi OS, Armbian, DietPi etc.):
 ```bash
-sudo apt install swig python3-dev python3-setuptools
+# Requirements to install lgpio C
+sudo apt install swig python3-dev python3-setuptools gcc make
 
 # Temporary fork of: wget https://github.com/joan2937/lg/archive/master.zip
 wget https://github.com/vickash/lg/archive/refs/heads/master.zip
 
+# Install lgpio C
 unzip master.zip
 cd lg-master
 make
 sudo make install
 
+# The latest Ruby 3 + YJIT is recommended, but you can use the system Ruby from apt too.
+# sudo apt install ruby ruby-dev
+
 gem install lgpio
 ```
 
@@ -76,4 +81,10 @@ Even when these are enabled, you may not have permission to access them. To run
   - Method names have the leading `lg` removed, since inside the `LGPIO` class.
   - Constants have leading `LG_` removed, as above.
   - "count" or "length" arguments associated with array args are not needed.
+  - Arg order for `_claim_` methods varies from lgpio C, so that gpio number always follows handle. The general pattern is `handle, gpio, flags, state`. This affects:
+    - `gpio_claim_input`
+    - `gpio_claim_output`
+    - `gpio_claim_alert`
+    - `group_claim_input`
+    - `group_claim_output`
 - Check the return values of your method calls. On failure, they return negative values, matching the `LG_` error codes at the bottom of the C API doc page.

data/examples/gpio_bench_in.rb

@@ -5,7 +5,7 @@ PIN       = 260
 COUNT     = 1000000
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP, PIN)
+LGPIO.gpio_claim_input(chip_handle, PIN, LGPIO::SET_PULL_UP)
 
 t1 = Time.now
 COUNT.times do

data/examples/gpio_bench_out.rb

@@ -5,7 +5,7 @@ PIN       = 272
 COUNT     = 1000000
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, PIN, LGPIO::LOW)
+LGPIO.gpio_claim_output(chip_handle, PIN, LGPIO::SET_PULL_NONE, LGPIO::LOW)
 
 t1 = Time.now
 COUNT.times do

data/examples/gpio_blink.rb

@@ -5,7 +5,7 @@ LED       = 272
 INTERVAL  = 0.25
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LED, LGPIO::LOW)
+LGPIO.gpio_claim_output(chip_handle, LED, LGPIO::SET_PULL_NONE, LGPIO::LOW)
 
 loop do
   LGPIO.gpio_write(chip_handle, LED, 1)

data/examples/gpio_group_in.rb

@@ -7,8 +7,8 @@ LEDS        = [272, 258]
 INIT_STATE  = [0, 0]
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.group_claim_input(chip_handle, LGPIO::SET_PULL_UP, BUTTONS)
-LGPIO.group_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LEDS, INIT_STATE)
+LGPIO.group_claim_input(chip_handle, BUTTONS, LGPIO::SET_PULL_UP)
+LGPIO.group_claim_output(chip_handle, LEDS, LGPIO::SET_PULL_NONE, INIT_STATE)
 
 # The inverted (active-low) state of each button controls the corresponding LED.
 loop do

data/examples/gpio_group_out.rb

@@ -7,7 +7,7 @@ INTERVAL    = 250_000 # 250ms
 TIMES       = 10
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.group_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LEDS, INIT_STATE)
+LGPIO.group_claim_output(chip_handle, LEDS, LGPIO::SET_PULL_NONE, INIT_STATE)
 
 # Convert us interval to seconds.
 interval = INTERVAL.to_f / 1_000_000

data/examples/gpio_momentary.rb

@@ -5,8 +5,8 @@ BUTTON    = 259
 LED       = 272
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP, BUTTON)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LED, LGPIO::LOW)
+LGPIO.gpio_claim_input(chip_handle, BUTTON, LGPIO::SET_PULL_UP)
+LGPIO.gpio_claim_output(chip_handle, LED, LGPIO::SET_PULL_NONE, LGPIO::LOW)
 
 loop do
   if LGPIO.gpio_read(chip_handle, BUTTON) == 0

data/examples/gpio_reports.rb

@@ -5,9 +5,9 @@ PIN       = 259
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN)
+LGPIO.gpio_claim_input(chip_handle, PIN, LGPIO::SET_PULL_NONE)
 LGPIO.gpio_set_debounce(chip_handle, PIN, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN)
+LGPIO.gpio_claim_alert(chip_handle, PIN, 0, LGPIO::BOTH_EDGES)
 LGPIO.gpio_start_reporting
 
 loop do

data/examples/gpio_rotary_encoder.rb

@@ -17,17 +17,17 @@ state_b  = 0
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 
 # Encoder pin setup
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_A)
+LGPIO.gpio_claim_input(chip_handle, PIN_A, LGPIO::SET_PULL_NONE)
 LGPIO.gpio_set_debounce(chip_handle, PIN_A, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_A)
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_B)
+LGPIO.gpio_claim_alert(chip_handle, PIN_A, 0, LGPIO::BOTH_EDGES)
+LGPIO.gpio_claim_input(chip_handle, PIN_B, LGPIO::SET_PULL_NONE)
 LGPIO.gpio_set_debounce(chip_handle, PIN_B, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_B)
+LGPIO.gpio_claim_alert(chip_handle, PIN_B, 0, LGPIO::BOTH_EDGES)
 
 # Switch pin setup
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP,     PIN_SW)
+LGPIO.gpio_claim_input(chip_handle, PIN_SW, LGPIO::SET_PULL_UP)
 LGPIO.gpio_set_debounce(chip_handle, PIN_SW, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::FALLING_EDGE, PIN_SW)
+LGPIO.gpio_claim_alert(chip_handle, PIN_SW, 0, LGPIO::FALLING_EDGE)
 
 # Start generating reports for GPIO level changes.
 LGPIO.gpio_start_reporting

data/examples/gpio_rotary_encoder_led.rb

@@ -21,15 +21,15 @@ led_duty = 0
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 
 # LED pin setup
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, PIN_LED, LGPIO::LOW)
+LGPIO.gpio_claim_output(chip_handle, PIN_LED, LGPIO::SET_PULL_NONE, LGPIO::LOW)
 
 # Encoder pin setup
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_A)
+LGPIO.gpio_claim_input(chip_handle, PIN_A, LGPIO::SET_PULL_NONE)
 LGPIO.gpio_set_debounce(chip_handle, PIN_A, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_A)
-LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_B)
+LGPIO.gpio_claim_alert(chip_handle, PIN_A, 0, LGPIO::BOTH_EDGES)
+LGPIO.gpio_claim_input(chip_handle, PIN_B, LGPIO::SET_PULL_NONE)
 LGPIO.gpio_set_debounce(chip_handle, PIN_B, 1)
-LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_B)
+LGPIO.gpio_claim_alert(chip_handle, PIN_B, 0, LGPIO::BOTH_EDGES)
 
 # Start generating reports for GPIO level changes.
 LGPIO.gpio_start_reporting

data/examples/gpio_wave.rb

@@ -7,7 +7,7 @@ INTERVAL    = 250_000 # 250ms
 TIMES       = 10
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.group_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LEDS, INIT_STATE)
+LGPIO.group_claim_output(chip_handle, LEDS, LGPIO::SET_PULL_NONE, INIT_STATE)
 
 # Generic pulse that updates both LED states (first element) each INTERVAL.
 generic_pulse = [ nil, 0b11, INTERVAL ]

data/examples/i2c_bb_aht10.rb

@@ -9,13 +9,19 @@ SOFT_RESET          = [0xBA]
 INIT_AND_CALIBRATE  = [0xE1, 0x08, 0x00]
 START_MEASUREMENT   = [0xAC, 0x33, 0x00]
 
-GPIO_CHIP = 0
+SCL_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 ADDRESS   = 0x38
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
 
 # Startup sequence
 sleep(POWER_ON_DELAY)
@@ -24,11 +30,15 @@ sleep(RESET_DELAY)
 i2c_bb.write(ADDRESS, INIT_AND_CALIBRATE)
 sleep(COMMAND_DELAY)
 
-# Read and close
+# Read
 i2c_bb.write(ADDRESS, START_MEASUREMENT)
 sleep(MEASURE_DELAY)
 bytes = i2c_bb.read(ADDRESS, DATA_LENGTH)
 
+# Close
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_handle)
+
 # Humidity uses the upper 4 bits of the shared byte as its lowest 4 bits.
 h_raw = ((bytes[1] << 16) | (bytes[2] << 8) | (bytes[3])) >> 4
 humidity = (h_raw.to_f / 2**20) * 100

data/examples/i2c_bb_search.rb

@@ -1,13 +1,23 @@
 require 'lgpio'
 
-GPIO_CHIP = 0
+SCL_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
+
 devices = i2c_bb.search
 
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_handle)
+
 if devices.empty?
   puts "No devices found on I2C bus"
 else

data/examples/i2c_bb_ssd1306_bench.rb

@@ -5,13 +5,19 @@ START_ARRAY = [0, 33, 0, 127, 34, 0, 7]
 PATTERN_1   = [64] + Array.new(1024) { 0b00110011 }
 PATTERN_2   = [64] + Array.new(1024) { 0b11001100 }
 
-GPIO_CHIP = 0
+SCL_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 ADDRESS   = 0x3C
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
 
 i2c_bb.write(ADDRESS, INIT_ARRAY)
 FRAME_COUNT = 400
@@ -25,7 +31,8 @@ start = Time.now
 end
 finish = Time.now
 
-LGPIO.chip_close(chip_handle)
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_handle)
 
 fps = FRAME_COUNT / (finish - start)
 # Also calculate C calls per second, using roughly 23 calls per byte written.

data/examples/pwm_sw.rb

@@ -7,7 +7,7 @@ PWM_OFFSET  = 0
 PWM_CYCLES  = 0    # 0 = infinite
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LED, LGPIO::LOW)
+LGPIO.gpio_claim_output(chip_handle, LED, LGPIO::SET_PULL_NONE, LGPIO::LOW)
 
 # Seamless loop from 0-100 and back.
 duty_cycles = (0..100).to_a + (1..99).to_a.reverse

data/examples/spi_bb_loopback.rb

@@ -10,7 +10,12 @@ ORDERS      = [:msbfirst, :lsbfirst]
 TX_BYTES    = [0, 1, 2, 3, 4, 5, 6, 7]
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, input: INPUT_PIN, output: OUTPUT_PIN)
+pin_hash    = {
+                clock:  { handle: chip_handle, line: CLOCK_PIN  },
+                input:  { handle: chip_handle, line: INPUT_PIN  },
+                output: { handle: chip_handle, line: OUTPUT_PIN },
+              }
+spi_bb      = LGPIO::SPIBitBang.new(pin_hash)
 
 puts "TX bytes => #{TX_BYTES.inspect}"
 

data/examples/spi_bb_sim_bench.rb

@@ -12,7 +12,12 @@ PATTERN_2   = [0x3C << 1] + [64] + Array.new(1179) { 0b11001100 }
 FRAME_COUNT = 400
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, input: INPUT_PIN, output: OUTPUT_PIN)
+pin_hash    = {
+                clock:  { handle: chip_handle, line: CLOCK_PIN  },
+                input:  { handle: chip_handle, line: INPUT_PIN  },
+                output: { handle: chip_handle, line: OUTPUT_PIN },
+              }
+spi_bb      = LGPIO::SPIBitBang.new(pin_hash)
 
 start = Time.now
 (FRAME_COUNT / 2).times do

data/examples/spi_bb_ssd1306_bench.rb

@@ -5,41 +5,55 @@ START_ARRAY = [0, 33, 0, 127, 34, 0, 7]
 PATTERN_1   = Array.new(1024) { 0b00110011 }
 PATTERN_2   = Array.new(1024) { 0b11001100 }
 
-GPIO_CHIP   = 0
-CLOCK_PIN   = 17
-OUTPUT_PIN  = 27
-SELECT_PIN  = 22
-RESET_PIN   = 5
-DC_PIN      = 6
-
-# Initialize
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, output: OUTPUT_PIN)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, SELECT_PIN, LGPIO::HIGH)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, RESET_PIN, LGPIO::LOW)
-LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, DC_PIN, LGPIO::LOW)
+# Pins for Radxa Zero 3W
+# Demonstration of how to use GPIOs across multiple /dev/gpiochip devices.
+pins = {
+  clock:  { chip: 1, line: 4 },
+  output: { chip: 3, line: 4 },
+  reset:  { chip: 3, line: 5 },
+  dc:     { chip: 3, line: 6 },
+  cs:     { chip: 3, line: 7 },
+}
+
+# Open chip handles without duplicating.
+open_handles = []
+pins.each_value do |hash|
+  if hash[:handle] = open_handles[hash[:chip]]
+  else
+    hash[:handle] = LGPIO.chip_open(hash[:chip])
+    open_handles[hash[:chip]] = hash[:handle]
+  end
+end
+
+puts pins.inspect
+
+spi_bb = LGPIO::SPIBitBang.new(clock: pins[:clock], output: pins[:output])
+LGPIO.gpio_claim_output(pins[:reset][:handle], pins[:reset][:line], LGPIO::SET_PULL_NONE, LGPIO::LOW)
+LGPIO.gpio_claim_output(pins[:dc][:handle], pins[:dc][:line], LGPIO::SET_PULL_NONE, LGPIO::LOW)
+LGPIO.gpio_claim_output(pins[:cs][:handle], pins[:cs][:line], LGPIO::SET_PULL_NONE, LGPIO::HIGH)
 
 # OLED STARTUP
-LGPIO.gpio_write(chip_handle, RESET_PIN, 1)
-LGPIO.gpio_write(chip_handle, DC_PIN, 0)
-spi_bb.transfer(write: INIT_ARRAY, select: SELECT_PIN)
+LGPIO.gpio_write(pins[:reset][:handle], pins[:reset][:line], 1)
+LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+spi_bb.transfer(write: INIT_ARRAY, select: pins[:cs])
 
 FRAME_COUNT = 400
 
 start = Time.now
 (FRAME_COUNT / 2).times do
-  LGPIO.gpio_write(chip_handle, DC_PIN, 0)
-  spi_bb.transfer(write: START_ARRAY, select: SELECT_PIN)
-  LGPIO.gpio_write(chip_handle, DC_PIN, 1)
-  spi_bb.transfer(write: PATTERN_1, select: SELECT_PIN)
-  LGPIO.gpio_write(chip_handle, DC_PIN, 0)
-  spi_bb.transfer(write: START_ARRAY, select: SELECT_PIN)
-  LGPIO.gpio_write(chip_handle, DC_PIN, 1)
-  spi_bb.transfer(write: PATTERN_2, select: SELECT_PIN)
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+  spi_bb.transfer(write: START_ARRAY, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 1)
+  spi_bb.transfer(write: PATTERN_1, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+  spi_bb.transfer(write: START_ARRAY, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 1)
+  spi_bb.transfer(write: PATTERN_2, select: pins[:cs])
 end
 finish = Time.now
 
-LGPIO.chip_close(chip_handle)
+# Close all handles.
+open_handles.compact.each { |h| LGPIO.chip_close(h) }
 
 fps = FRAME_COUNT / (finish - start)
 # Also calculate C calls per second, using roughly 20 calls per byte written.

data/ext/lgpio/lgpio.c

@@ -60,12 +60,12 @@ static VALUE gpio_get_mode(VALUE self, VALUE handle, VALUE gpio) {
   return INT2NUM(result);
 }
 
-static VALUE gpio_claim_output(VALUE self, VALUE handle, VALUE flags, VALUE gpio, VALUE level) {
+static VALUE gpio_claim_output(VALUE self, VALUE handle, VALUE gpio, VALUE flags, VALUE level) {
   int result = lgGpioClaimOutput(NUM2INT(handle), NUM2INT(flags), NUM2INT(gpio), NUM2INT(level));
   return INT2NUM(result);
 }
 
-static VALUE gpio_claim_input(VALUE self, VALUE handle, VALUE flags, VALUE gpio) {
+static VALUE gpio_claim_input(VALUE self, VALUE handle, VALUE gpio, VALUE flags) {
   int result = lgGpioClaimInput(NUM2INT(handle), NUM2INT(flags), NUM2INT(gpio));
   return INT2NUM(result);
 }
@@ -85,7 +85,7 @@ static VALUE gpio_write(VALUE self, VALUE handle, VALUE gpio, VALUE level) {
   return INT2NUM(result);
 }
 
-static VALUE group_claim_input(VALUE self, VALUE handle, VALUE flags, VALUE gpios) {
+static VALUE group_claim_input(VALUE self, VALUE handle, VALUE gpios, VALUE flags) {
   int count = rb_array_len(gpios);
   int lgGpios[count];
   int i;
@@ -96,7 +96,7 @@ static VALUE group_claim_input(VALUE self, VALUE handle, VALUE flags, VALUE gpio
   return INT2NUM(result);
 }
 
-static VALUE group_claim_output(VALUE self, VALUE handle, VALUE flags, VALUE gpios, VALUE levels) {
+static VALUE group_claim_output(VALUE self, VALUE handle, VALUE gpios, VALUE flags, VALUE levels) {
   int count = rb_array_len(gpios);
   int lgGpios[count];
   int lgLevels[count];
@@ -130,7 +130,7 @@ static VALUE gpio_set_debounce(VALUE self, VALUE handle, VALUE gpio, VALUE debou
   return INT2NUM(result);
 }
 
-static VALUE gpio_claim_alert(VALUE self, VALUE handle, VALUE flags, VALUE eFlags, VALUE gpio) {
+static VALUE gpio_claim_alert(VALUE self, VALUE handle, VALUE gpio, VALUE flags, VALUE eFlags) {
   int result = lgGpioClaimAlert(NUM2INT(handle), NUM2INT(flags), NUM2INT(eFlags), NUM2INT(gpio), -1);
   return INT2NUM(result);
 }

data/lib/lgpio/i2c_bitbang.rb

@@ -2,24 +2,32 @@ module LGPIO
   class I2CBitBang
     VALID_ADDRESSES = (0x08..0x77).to_a
 
-    attr_reader :handle, :scl, :sda
+    attr_reader :scl_handle, :scl_line, :sda_handle, :sda_line
 
-    def initialize(handle, scl, sda)
-      @handle = handle
-      @scl    = scl
-      @sda    = sda
-      @sda_state = nil
+    def initialize(options={})
+      scl  = options[:scl]
+      sda  = options[:sda]
+
+      @scl_handle = scl[:handle] if scl
+      @scl_line   = scl[:line]   if scl
+      raise ArgumentError, ":scl pin required as Hash, with :handle and :line required" unless (@scl_handle && @scl_line)
+
+      @sda_handle = sda[:handle] if sda
+      @sda_line   = sda[:line]   if sda
+      raise ArgumentError, ":sda pin required as Hash, with :handle and :line required" unless (@sda_handle && @sda_line)
+
+      @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)
+      LGPIO.gpio_claim_output(scl_handle, scl_line, LGPIO::SET_PULL_NONE, LGPIO::HIGH)
+      LGPIO.gpio_claim_output(sda_handle, sda_line, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, LGPIO::HIGH)
     end
 
     def set_sda(value)
       return if (@sda_state == value)
-      LGPIO.gpio_write(handle, sda, @sda_state = value)
+      LGPIO.gpio_write(sda_handle, sda_line, @sda_state = value)
     end
 
     def write_form(address)
@@ -31,28 +39,28 @@ module LGPIO
     end
 
     def start
-      LGPIO.gpio_write(handle, sda, 0)
-      LGPIO.gpio_write(handle, scl, 0)
+      LGPIO.gpio_write(sda_handle, sda_line, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
     end
 
     def stop
-      LGPIO.gpio_write(handle, sda, 0)
-      LGPIO.gpio_write(handle, scl, 1)
-      LGPIO.gpio_write(handle, sda, 1)
+      LGPIO.gpio_write(sda_handle, sda_line, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      LGPIO.gpio_write(sda_handle, sda_line, 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)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      bit = LGPIO.gpio_read(sda_handle, sda_line)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
       bit
     end
 
     def write_bit(bit)
       set_sda(bit)
-      LGPIO.gpio_write(handle, scl, 1)
-      LGPIO.gpio_write(handle, scl, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
     end
 
     def read_byte(ack)

data/lib/lgpio/spi_bitbang.rb

@@ -1,16 +1,24 @@
 module LGPIO
   class SPIBitBang
-    attr_reader :handle, :clock, :input, :output
+    attr_reader :clock_handle, :input_handle, :output_handle
+    attr_reader :clock_line, :input_line, :output_line
 
     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]
+      clock  = options[:clock]
+      input  = options[:input]
+      output = options[:output]
 
-      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
+      @clock_handle   = clock[:handle] if clock
+      @clock_line     = clock[:line]   if clock
+      raise ArgumentError, ":clock pin required as Hash, with :handle and :line required" unless (@clock_handle && @clock_line)
+
+      @input_handle   = input[:handle]  if input
+      @input_line     = input[:line]    if input
+      @output_handle  = output[:handle] if output
+      @output_line    = output[:line]   if output
+      unless ((@input_handle && @input_line) || (@output_handle && @output_line))
+        raise ArgumentError, "either :input or :output pin required as Hash, with :handle and :line required"
+      end
 
       @output_state = nil
       initialize_pins
@@ -21,38 +29,38 @@ module LGPIO
     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
+      LGPIO.gpio_claim_output(clock_handle,  clock_line,  LGPIO::SET_PULL_NONE, LGPIO::LOW)
+      LGPIO.gpio_claim_input(input_handle,   input_line,  LGPIO::SET_PULL_NONE)             if input_line
+      LGPIO.gpio_claim_output(output_handle, output_line, LGPIO::SET_PULL_NONE, LGPIO::LOW) if output_line
     end
 
     def set_output(level)
       return if (level == @output_state)
-      LGPIO.gpio_write(handle, output, @output_state = level)
+      LGPIO.gpio_write(output_handle, output_line, @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)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
       when 1
-        LGPIO.gpio_write(handle, clock, 1)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
         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(clock_handle, clock_line, 0)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) 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)
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
       when 3
-        LGPIO.gpio_write(handle, clock, 0)
+        LGPIO.gpio_write(clock_handle, clock_line, 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(clock_handle, clock_line, 1)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
       else
         raise ArgumentError, "invalid SPI mode: #{mode} given"
       end
@@ -87,9 +95,9 @@ module LGPIO
       # Idle clock state depends on SPI mode.
       case mode
       when 0..1
-        LGPIO.gpio_write(handle, clock, 0)
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
       when 2..3
-        LGPIO.gpio_write(handle, clock, 1)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
       else
         raise ArgumentError, "invalid SPI mode: #{mode} given"
       end
@@ -97,7 +105,7 @@ module LGPIO
       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
+      LGPIO.gpio_write(select[:handle], select[:line], 0) if select
 
       i = 0
       while (i < read) || (i < write.length)
@@ -106,7 +114,7 @@ module LGPIO
         i = i + 1
       end
 
-      LGPIO.gpio_write(handle, select, 1) if select
+      LGPIO.gpio_write(select[:handle], select[:line], 1) if select
       read_bytes
     end
   end

data/lib/lgpio/version.rb

@@ -1,3 +1,3 @@
 module LGPIO
-  VERSION = "0.1.8"
+  VERSION = "0.1.10"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.8
+  version: 0.1.10
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-19 00:00:00.000000000 Z
+date: 2024-09-28 00:00:00.000000000 Z
 dependencies: []
 description: Use Linux GPIO, I2C, SPI and PWM in Ruby
 email: mail@vickash.com
@@ -82,7 +82,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.16
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
 summary: Use Linux GPIO, I2C, SPI and PWM in Ruby