lgpio 0.1.2 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4bb351b8041dc3f5e78ed92128c3c971cf3f9e35d247a71e8d4ce56acec87f32
-  data.tar.gz: a4df4836decc51de97ad16093bbd19e649cd02b675d6511c601feddde0cded66
+  metadata.gz: e24e221cb39d27714d3fdd9486c47dd01e33115980d29e5104a455e14fd40890
+  data.tar.gz: 4ffd6e35644bc8dcde49486cd43d8e7ca73ebbfe9b46955a8de89a4ecff49d33
 SHA512:
-  metadata.gz: f94daeeaba65d22c4ee2e0205a9399f18f886cc5f42e15f53a4991381756b7a33d97d29113918b809b6ff96d7900a327ee26d441d9249e86020cee7c21c34765
-  data.tar.gz: 367559fcd9750f88e728b80836c3dfa7d9273dcb2c734bc67faed29b23e177fc03e9e18df9678533907f3ddbe85be5d4d443a5d45404a03322ac09e586827e11
+  metadata.gz: 5060a2fd7a5ef20a1de29f01a87aa2ff2639c9d0e9005594de672d7fa011df48e7a65b893ad4310d07d780f9677c1544ccc80018a5bb4794e014513f4864fae4
+  data.tar.gz: 16e6a32af1a358ffcf18c7864d2748527f635a83f42734fc3191ecb6eed7fb50cef3ffe4370651b063fde6e4a28bd2075a12b6adb8d04b3e4646353d973515c3

data/README.md

@@ -1,16 +1,54 @@
 # lgpio
 
-Ruby bindings for the [lgpio (lg)](https://github.com/joan2937/lg) C library, which provides GPIO, PWM, I2C, SPI and Serial features on single-board-computers (SBCs) running Linux.
+Ruby bindings for the [lgpio (lg)](https://github.com/joan2937/lg) C library, for Linux on single board computers (SBCs), like the Raspberry Pi and its competitors.
 
-- [lg homepage](https://abyz.me.uk/lg/index.html)
+## Features
+- GPIO Read/Write
+- GPIO Group Read/Write
+- GPIO Alerts / Callbacks
+  - lg generates alerts at high speed, in a separate thread. In Ruby they can be read from a queue as part of your application loop.
+- PWM Output
+  - Software timed on any pin. No interface for hardware PWM yet.
+- Wave
+  - Software timed on any pin, as with PWM.
+- I2C
+- SPI
 
-### Progress:
+## Installation
+On Debian-based Linuxes (RaspberryPi OS, Armbian, DietPi etc.):
+```bash
+sudo apt install swig python3-dev python3-setuptools
 
-- [x] GPIO Read/Write
-- [x] GPIO Group Read/Write
-- [x] GPIO Alerts / Callbacks (read from a queue)
-- [x] PWM (software-timed)
-- [x] Wave (software-timed)
-- [ ] I2C
-- [ ] SPI
-- [ ] Serial
+# NOTE: There's a bug with GPIO numbers > 255.
+# If you need to use those, wget the second URL instead, until that fix is merged.
+wget https://github.com/joan2937/lg/archive/master.zip
+# wget https://github.com/vickash/lg/archive/refs/heads/master.zip
+
+unzip master.zip
+cd lg-master
+make
+sudo make install
+
+gem install lgpio
+```
+
+## Enabling Hardware & Permissions
+Depending on your SBC and Linux distro/version, you may need to manually enable I2C and SPI hardware. You may use the setup or config tool that came with your distro for that.
+
+You may also not have permission to access some or all of the GPIO and peripherals. To run without `sudo`, you will need read+write permission to some or all of the following devices:
+```
+/dev/gpiochip* (For GPIO, example: /dev/gpiochip0)
+/dev/i2c-*     (For I2C,  example: /dev/i2c-1)
+/dev/spidev*   (For SPI,  example: /dev/spidev-0.1)
+```
+
+## Documentation
+- See examples folder for demos of every implemented interface.
+  - Development was done on an Orange Pi Zero 2W. Your GPIO numbers will be different, so change them.
+- For more info, see the [lgpio C API docs.](https://abyz.me.uk/lg/lgpio.html)
+- As much as possible, the Ruby methods closely follow the C API functions, except:
+  - Snake case instead of camel case names for methods.
+  - 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.
+- Check the return values of your method calls. On failure, they return negative values values, matching the `LG_` error codes at the bottom of the C API doc page.

data/examples/i2c_aht10.rb

@@ -0,0 +1,36 @@
+require 'lgpio'
+
+I2C_DEV = 2
+POWER_ON_DELAY      = 0.100
+RESET_DELAY         = 0.020
+COMMAND_DELAY       = 0.010
+MEASURE_DELAY       = 0.080
+DATA_LENGTH         = 6
+SOFT_RESET          = [0xBA]
+INIT_AND_CALIBRATE  = [0xE1, 0x08, 0x00]
+START_MEASUREMENT   = [0xAC, 0x33, 0x00]
+
+aht10_handle = LGPIO.i2c_open(I2C_DEV, 0x38, 0)
+
+# Startup sequence
+sleep(POWER_ON_DELAY)
+LGPIO.i2c_write_device(aht10_handle, SOFT_RESET)
+sleep(RESET_DELAY)
+LGPIO.i2c_write_device(aht10_handle, INIT_AND_CALIBRATE)
+sleep(COMMAND_DELAY)
+
+# Read and close
+LGPIO.i2c_write_device(aht10_handle, START_MEASUREMENT)
+sleep(MEASURE_DELAY)
+bytes = LGPIO.i2c_read_device(aht10_handle, DATA_LENGTH)
+LGPIO.i2c_close(aht10_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
+
+# Temperature uses the lower 4 bits of the shared byte as its highest 4 bits.
+t_raw = ((bytes[3] & 0x0F) << 16) | (bytes[4] << 8) | bytes[5]
+temperature = (t_raw.to_f / 2**20) * 200 - 50
+
+puts "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - Temperature: #{temperature.round(2)} \xC2\xB0C | Humidity: #{humidity.round(2)} %"

data/examples/i2c_aht10_zip.rb

@@ -0,0 +1,36 @@
+require 'lgpio'
+
+I2C_DEV = 2
+POWER_ON_DELAY      = 0.100
+RESET_DELAY         = 0.020
+COMMAND_DELAY       = 0.010
+MEASURE_DELAY       = 0.080
+SOFT_RESET          = [5, 1, 0xBA, 0]
+INIT_AND_CALIBRATE  = [5, 3, 0xE1, 0x08, 0x00, 0]
+START_MEASUREMENT   = [5, 3, 0xAC, 0x33, 0x00, 0]
+READ_SIX            = [4, 6, 0]
+
+aht10_handle = LGPIO.i2c_open(I2C_DEV, 0x38, 0)
+
+# Startup sequence
+sleep(POWER_ON_DELAY)
+LGPIO.i2c_zip(aht10_handle, SOFT_RESET, 0)
+sleep(RESET_DELAY)
+LGPIO.i2c_zip(aht10_handle, INIT_AND_CALIBRATE, 0)
+sleep(COMMAND_DELAY)
+
+# Read and close
+LGPIO.i2c_zip(aht10_handle, START_MEASUREMENT, 0)
+sleep(MEASURE_DELAY)
+bytes = LGPIO.i2c_zip(aht10_handle, READ_SIX, 6)
+LGPIO.i2c_close(aht10_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
+
+# Temperature uses the lower 4 bits of the shared byte as its highest 4 bits.
+t_raw = ((bytes[3] & 0x0F) << 16) | (bytes[4] << 8) | bytes[5]
+temperature = (t_raw.to_f / 2**20) * 200 - 50
+
+puts "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - Temperature: #{temperature.round(2)} \xC2\xB0C | Humidity: #{humidity.round(2)} %"

data/examples/i2c_ssd1306_bench.rb

@@ -0,0 +1,25 @@
+require 'lgpio'
+
+I2C_DEV = 2
+INIT_ARRAY  = [0, 168, 63, 211, 0, 64, 161, 200, 218, 18, 164, 166, 213, 128, 219, 32, 217, 241, 141, 20, 32, 0, 175]
+START_ARRAY = [0, 33, 0, 127, 34, 0, 7]
+BLANK_ARRAY = [64] + Array.new(1024) { 0 }
+FILL_ARRAY  = [64] + Array.new(1024) { 255 }
+
+ssd1306_handle = LGPIO.i2c_open(I2C_DEV, 0x3C, 0)
+LGPIO.i2c_write_device(ssd1306_handle, INIT_ARRAY)
+FRAME_COUNT = 100
+
+start = Time.now
+(FRAME_COUNT / 2).times do
+  LGPIO.i2c_write_device(ssd1306_handle, START_ARRAY)
+  LGPIO.i2c_write_device(ssd1306_handle, FILL_ARRAY)
+  LGPIO.i2c_write_device(ssd1306_handle, START_ARRAY)
+  LGPIO.i2c_write_device(ssd1306_handle, BLANK_ARRAY)
+end
+finish = Time.now
+
+LGPIO.i2c_close(ssd1306_handle)
+
+fps = FRAME_COUNT / (finish - start)
+puts "SSD1306 benchmark result: #{fps.round(2)} fps"

data/examples/reports.rb

@@ -6,6 +6,7 @@ PIN       = 76
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 
 LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN)
+LGPIO.gpio_set_debounce(chip_handle, PIN, 1)
 LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN)
 LGPIO.gpio_start_reporting
 

data/examples/rotary_encoder.rb

@@ -18,12 +18,15 @@ chip_handle = LGPIO.chip_open(GPIO_CHIP)
 
 # Encoder pin setup
 LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_A)
+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_set_debounce(chip_handle, PIN_B, 1)
 LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_B)
 
 # Switch pin setup
 LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP,     PIN_SW)
+LGPIO.gpio_set_debounce(chip_handle, PIN_SW, 1)
 LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::FALLING_EDGE, PIN_SW)
 
 # Start generating reports for GPIO level changes.

data/examples/rotary_encoder_led.rb

@@ -0,0 +1,56 @@
+#
+# Demo of a simple 30-detent rotary encoder.
+# PIN_A = CLK/CLOCK, PIN_B = DT/DATA, PIN_SW = SWITCH
+#
+require 'lgpio'
+
+GPIO_CHIP = 0
+PIN_A     = 76
+PIN_B     = 228
+
+PIN_LED     = 260
+PWM_FREQ    = 500
+PWM_OFFSET  = 0
+PWM_CYCLES  = 0    # 0 = infinite
+
+# Encoder state
+state_a  = 0
+state_b  = 0
+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)
+
+# Encoder pin setup
+LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_NONE, PIN_A)
+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_set_debounce(chip_handle, PIN_B, 1)
+LGPIO.gpio_claim_alert(chip_handle, 0, LGPIO::BOTH_EDGES, PIN_B)
+
+# Start generating reports for GPIO level changes.
+LGPIO.gpio_start_reporting
+
+# Get and reports to update state.
+loop do
+  report = LGPIO.gpio_get_report
+  if report
+    if report[:gpio] == PIN_A
+      # Half quadrature, so we count every detent.
+      state_a = report[:level]
+    elsif report[:gpio] == PIN_B
+      delta = (report[:level] == state_a) ? -1 : 1
+      state_b = report[:level]
+      
+      led_duty += delta
+      led_duty = 0 if led_duty < 0
+      led_duty = 100 if led_duty > 100
+      LGPIO.tx_pwm(chip_handle, PIN_LED, PWM_FREQ, led_duty, PWM_OFFSET, PWM_CYCLES)
+    end
+  else
+    sleep(0.001)
+  end
+end

data/examples/spi_loopback.rb

@@ -0,0 +1,18 @@
+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)
+
+tx_bytes = [0, 1, 2, 3, 4, 5, 6, 7]
+puts "TX bytes: #{tx_bytes.inspect}"
+
+# rx_bytes == tx_bytes if MOSI looped back to MISO.
+# rx_byte all 255 when MOSI and MISO not connected.
+rx_bytes = LGPIO.spi_xfer(spi_handle, tx_bytes)
+puts "RX bytes: #{rx_bytes.inspect}"
+
+LGPIO.spi_close(spi_handle)

data/examples/spi_read.rb

@@ -0,0 +1,14 @@
+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)

data/examples/spi_ws2812.rb

@@ -0,0 +1,60 @@
+#
+# 2.4 MHz SPI method for writing WS2812 addressable LEDs
+# Based on:https://learn.adafruit.com/dma-driven-neopixels/overview
+#
+require 'lgpio'
+
+# WS2812 Constants
+NP_ONE   = 0b110
+NP_ZERO  = 0b100
+NP_START = [0]
+NP_END   = Array.new(90) { 0 }
+BITS     = (0..7).to_a.reverse
+
+# SPI Config
+SPI_DEV  = 1
+SPI_CHAN = 0
+SPI_MODE = 0
+SPI_BAUD = 2_400_000
+
+# Map array of pixel values (3 bytes each) to raw SPI bytes (1bit -> 3 bits).
+def pixel_to_raw_spi_bytes(pixel_arr)
+  raw_spi_bytes = []
+  pixel_arr.flatten.each do |byte|
+    long = 0b0
+    for i in BITS do
+      long = long << 3
+      if byte[i] == 0
+        long |= NP_ZERO
+      else
+        long |= NP_ONE
+      end
+    end
+    # Pack as big-endian uint32, then unpack to bytes, taking lowest 24 bits only.
+    long = [long].pack('L>')
+    raw_spi_bytes << long.unpack('C*')[1..3]
+  end
+  return raw_spi_bytes.flatten
+end
+
+# 4 pixels: RGBW. Data order per pixel is GRB.
+pixels_on = [
+  0, 255, 0,
+  255, 0, 0,
+  0, 0, 255,
+  255, 255, 255,
+]
+data_on = NP_START + pixel_to_raw_spi_bytes(pixels_on) + NP_END
+
+# 4 pixels, all off.
+pixels_off = Array.new(12) { 0 }
+data_off = NP_START + pixel_to_raw_spi_bytes(pixels_off) + NP_END
+
+spi_handle = LGPIO.spi_open(SPI_DEV, SPI_CHAN, SPI_BAUD, SPI_MODE)
+
+loop do
+  LGPIO.spi_write(spi_handle, data_on)
+  sleep 0.5
+  LGPIO.spi_write(spi_handle, data_off)
+  sleep 0.5
+end

data/ext/lgpio/lgpio.c

@@ -83,6 +83,11 @@ static VALUE group_write(VALUE self, VALUE handle, VALUE gpio, VALUE bits, VALUE
   return INT2NUM(result);
 }
 
+static VALUE gpio_set_debounce(VALUE self, VALUE handle, VALUE gpio, VALUE debounce) {
+  int result =  lgGpioSetDebounce(NUM2INT(handle), NUM2INT(gpio), NUM2INT(debounce));
+  return INT2NUM(result);
+}
+
 static VALUE gpio_claim_alert(VALUE self, VALUE handle, VALUE flags, VALUE eFlags, VALUE gpio) {
   int result = lgGpioClaimAlert(NUM2INT(handle), NUM2INT(flags), NUM2INT(eFlags), NUM2INT(gpio), -1);
   return INT2NUM(result);
@@ -101,12 +106,13 @@ void queue_gpio_reports(int count, lgGpioAlert_p events, void *data){
 
 static VALUE gpio_start_reporting(VALUE self) {
   lgGpioSetSamplesFunc(queue_gpio_reports, NULL);
+  return Qnil;
 }
 
-static VALUE gpio_get_report(VALUE self){  
+static VALUE gpio_get_report(VALUE self){
   VALUE hash = rb_hash_new();
   bool popped = false;
-  
+
   pthread_mutex_lock(&queueLock);
   // qWritePos is where the NEXT report will go. Always trail it by 1.
   if (qWritePos - qReadPos != 1){
@@ -170,6 +176,132 @@ static VALUE tx_wave(VALUE self, VALUE handle, VALUE lead_gpio, VALUE pulses) {
   return INT2NUM(result);
 }
 
+static VALUE i2c_open(VALUE self, VALUE i2cDev, VALUE i2cAddr, VALUE i2cFlags){
+  int handle = lgI2cOpen(NUM2INT(i2cDev), NUM2INT(i2cAddr), NUM2INT(i2cFlags));
+  return INT2NUM(handle);
+}
+
+static VALUE i2c_close(VALUE self, VALUE handle){
+  int result = lgI2cClose(NUM2INT(handle));
+  return INT2NUM(result);
+}
+
+static VALUE i2c_write_device(VALUE self, VALUE handle, VALUE byteArray){
+  int count = RARRAY_LEN(byteArray);
+  uint8_t txBuf[count];
+  VALUE currentByte;
+  for(int i=0; i<count; i++){
+    currentByte = rb_ary_entry(byteArray, i);
+    Check_Type(currentByte, T_FIXNUM);
+    txBuf[i] = NUM2CHR(currentByte);
+  }
+
+  int result = lgI2cWriteDevice(NUM2INT(handle), txBuf, count);
+  return INT2NUM(result);
+}
+
+static VALUE i2c_read_device(VALUE self, VALUE handle, VALUE count){
+  int rxCount = NUM2INT(count);
+  uint8_t rxBuf[rxCount];
+
+  int result = lgI2cReadDevice(NUM2INT(handle), rxBuf, rxCount);
+  if(result < 0) return INT2NUM(result);
+
+  VALUE retArray = rb_ary_new2(rxCount);
+  for(int i=0; i<rxCount; i++){
+    rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
+  }
+  return retArray;
+}
+
+static VALUE i2c_zip(VALUE self, VALUE handle, VALUE txArray, VALUE rb_rxCount){
+  int txCount = RARRAY_LEN(txArray);
+  uint8_t txBuf[txCount];
+  VALUE currentByte;
+  for(int i=0; i<txCount; i++){
+    currentByte = rb_ary_entry(txArray, i);
+    Check_Type(currentByte, T_FIXNUM);
+    txBuf[i] = NUM2CHR(currentByte);
+  }
+
+  int rxCount = NUM2INT(rb_rxCount);
+  uint8_t rxBuf[rxCount+1];
+
+  // Buffer size must be rxCount+1 or result is LG_BAD_I2C_RLEN
+  int result = lgI2cZip(NUM2INT(handle), txBuf, txCount, rxBuf, rxCount+1);
+  if(result < 0) return INT2NUM(result);
+
+  if (rxCount == 0) return Qnil;
+  VALUE retArray = rb_ary_new2(rxCount);
+  for(int i=0; i<rxCount; i++){
+    rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
+  }
+  return retArray;
+}
+
+static VALUE spi_open(VALUE self, VALUE spiDev, VALUE spiChan, VALUE spiBaud, VALUE spiFlags){
+  int handle = lgSpiOpen(NUM2INT(spiDev), NUM2INT(spiChan), NUM2INT(spiBaud), NUM2INT(spiFlags));
+  return INT2NUM(handle);
+}
+
+static VALUE spi_close(VALUE self, VALUE handle){
+  int result = lgSpiClose(NUM2INT(handle));
+  return INT2NUM(result);
+}
+
+static VALUE spi_read(VALUE self, VALUE handle, VALUE rxCount){
+  int count = NUM2INT(rxCount);
+
+  // Not sure if this needs null termination like I2C. +1 won't hurt.
+  uint8_t rxBuf[count+1];
+
+  int result = lgSpiRead(NUM2INT(handle), rxBuf, count);
+  if(result < 0) return INT2NUM(result);
+
+  VALUE retArray = rb_ary_new2(count);
+  for(int i=0; i<count; i++){
+    rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
+  }
+  return retArray;
+}
+
+static VALUE spi_write(VALUE self, VALUE handle, VALUE txArray){
+  int count = RARRAY_LEN(txArray);
+  uint8_t txBuf[count];
+  VALUE currentByte;
+  for(int i=0; i<count; i++){
+    currentByte = rb_ary_entry(txArray, i);
+    Check_Type(currentByte, T_FIXNUM);
+    txBuf[i] = NUM2CHR(currentByte);
+  }
+
+  int result = lgSpiWrite(NUM2INT(handle), txBuf, count);
+  return INT2NUM(result);
+}
+
+static VALUE spi_xfer(VALUE self, VALUE handle, VALUE txArray){
+  int count = RARRAY_LEN(txArray);
+  uint8_t txBuf[count];
+  VALUE currentByte;
+  for(int i=0; i<count; i++){
+    currentByte = rb_ary_entry(txArray, i);
+    Check_Type(currentByte, T_FIXNUM);
+    txBuf[i] = NUM2CHR(currentByte);
+  }
+
+  // Not sure if this needs null termination like I2C. +1 won't hurt.
+  uint8_t rxBuf[count+1];
+
+  int result = lgSpiXfer(NUM2INT(handle), txBuf, rxBuf, count);
+  if(result < 0) return INT2NUM(result);
+
+  VALUE retArray = rb_ary_new2(count);
+  for(int i=0; i<count; i++){
+    rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
+  }
+  return retArray;
+}
+
 void Init_lgpio(void) {
   // Modules
   VALUE mLGPIO = rb_define_module("LGPIO");
@@ -198,8 +330,9 @@ void Init_lgpio(void) {
   rb_define_singleton_method(mLGPIO, "group_free",          group_free,         2);
   rb_define_singleton_method(mLGPIO, "group_read",          group_read,         2);
   rb_define_singleton_method(mLGPIO, "group_write",         group_write,        4);
-  
+
   // Alerts / Reports
+  rb_define_singleton_method(mLGPIO, "gpio_set_debounce",     gpio_set_debounce,     3);
   rb_define_singleton_method(mLGPIO, "gpio_claim_alert",      gpio_claim_alert,      4);
   rb_define_singleton_method(mLGPIO, "gpio_start_reporting",  gpio_start_reporting,  0);
   rb_define_singleton_method(mLGPIO, "gpio_get_report",       gpio_get_report,       0);
@@ -213,4 +346,18 @@ void Init_lgpio(void) {
   rb_define_singleton_method(mLGPIO, "tx_pwm",   tx_pwm,   6);
   rb_define_singleton_method(mLGPIO, "tx_servo", tx_servo, 6);
   rb_define_singleton_method(mLGPIO, "tx_wave",  tx_wave,  3);
+
+  // I2C
+  rb_define_singleton_method(mLGPIO, "i2c_open",           i2c_open,          3);
+  rb_define_singleton_method(mLGPIO, "i2c_close",          i2c_close,         1);
+  rb_define_singleton_method(mLGPIO, "i2c_write_device",   i2c_write_device,  2);
+  rb_define_singleton_method(mLGPIO, "i2c_read_device",    i2c_read_device,   2);
+  rb_define_singleton_method(mLGPIO, "i2c_zip",            i2c_zip,           3);
+
+  // SPI
+  rb_define_singleton_method(mLGPIO, "spi_open",           spi_open,          4);
+  rb_define_singleton_method(mLGPIO, "spi_close",          spi_close,         1);
+  rb_define_singleton_method(mLGPIO, "spi_read",           spi_read,          2);
+  rb_define_singleton_method(mLGPIO, "spi_write",          spi_write,         2);
+  rb_define_singleton_method(mLGPIO, "spi_xfer",           spi_xfer,          2);
 }

data/lib/lgpio/version.rb

@@ -1,3 +1,3 @@
 module LGPIO
-  VERSION = "0.1.2"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.2
+  version: 0.1.3
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-07-31 00:00:00.000000000 Z
+date: 2024-08-03 00:00:00.000000000 Z
 dependencies: []
 description: Use GPIO / PWM / I2C / SPI / UART on Linux SBCs in Ruby
 email: mail@vickash.com
@@ -26,10 +26,17 @@ files:
 - examples/blink.rb
 - examples/group_in.rb
 - examples/group_out.rb
+- examples/i2c_aht10.rb
+- examples/i2c_aht10_zip.rb
+- examples/i2c_ssd1306_bench.rb
 - examples/momentary.rb
 - examples/pwm.rb
 - examples/reports.rb
 - examples/rotary_encoder.rb
+- examples/rotary_encoder_led.rb
+- examples/spi_loopback.rb
+- examples/spi_read.rb
+- examples/spi_ws2812.rb
 - examples/wave.rb
 - ext/lgpio/extconf.rb
 - ext/lgpio/lgpio.c