lgpio 0.1.1 → 0.1.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d173e84c707ec6e3d84715dbc7c56287a22d735fbbf118adc4d3b602513b852e
-  data.tar.gz: cb8d9acbdc1ed6da8fe9f037f8b837ee989b50d48b173980165b34e5c19d9b92
+  metadata.gz: e24e221cb39d27714d3fdd9486c47dd01e33115980d29e5104a455e14fd40890
+  data.tar.gz: 4ffd6e35644bc8dcde49486cd43d8e7ca73ebbfe9b46955a8de89a4ecff49d33
 SHA512:
-  metadata.gz: 4959700837149d70e16f550cbd02e13d03b4507ec1b50910c45bf7809e2c711547939ad50d2ba559c0b167befb6c670202e5de371bbe40bf764032d580e94830
-  data.tar.gz: 360a46aa061edb191ce80f67be784ac4edae21d7126cb4e05c3ce3812d416d2daa6f804ecfa532c790637d51f63010e01a07277971897fa26d7442f1c581a251
+  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
-- [ ] GPIO Callbacks
-- [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

@@ -0,0 +1,19 @@
+require 'lgpio'
+
+GPIO_CHIP = 0
+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
+
+loop do
+  report = LGPIO.gpio_get_report
+  report ? puts(report) : sleep(0.001)
+end
+
+LGPIO.gpio_free(chip_handle, PIN)
+LGPIO.chip_close(chip_handle)

data/examples/rotary_encoder.rb

@@ -0,0 +1,54 @@
+#
+# 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_SW    = 226
+
+# Encoder state
+position = 0
+state_a  = 0
+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_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.
+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
+      position += delta
+      state_b = report[:level]
+      puts "Position: #{position}"
+    elsif report[:gpio] == PIN_SW
+      position = 0
+      puts "Position: 0"
+    end
+  else
+    sleep(0.001)
+  end
+end

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

@@ -1,6 +1,13 @@
 #include <lgpio.h>
 #include <ruby.h>
 
+// Set up a queue for up to 2**16 GPIO reports.
+static pthread_mutex_t queueLock;
+#define QUEUE_LENGTH UINT16_MAX + 1
+static lgGpioReport_t reportQueue[QUEUE_LENGTH];
+static uint16_t qWritePos = 1;
+static uint16_t qReadPos  = 0;
+
 static VALUE chip_open(VALUE self, VALUE gpio_dev) {
   int result = lgGpiochipOpen(NUM2INT(gpio_dev));
   return INT2NUM(result);
@@ -76,6 +83,56 @@ 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);
+}
+
+void queue_gpio_reports(int count, lgGpioAlert_p events, void *data){
+  pthread_mutex_lock(&queueLock);
+  for(int i=0; i<count; i++) {
+    memcpy(&reportQueue[qWritePos], &events[i].report, sizeof(lgGpioReport_t));
+    qWritePos += 1;
+    // qReadPos is the LAST report read. If passing by 1, increment it too. Lose oldest data first.
+    if (qWritePos - qReadPos == 1) qReadPos += 1;
+  }
+  pthread_mutex_unlock(&queueLock);
+}
+
+static VALUE gpio_start_reporting(VALUE self) {
+  lgGpioSetSamplesFunc(queue_gpio_reports, NULL);
+  return Qnil;
+}
+
+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){
+    qReadPos += 1;
+    rb_hash_aset(hash, ID2SYM(rb_intern("timestamp")), ULL2NUM(reportQueue[qReadPos].timestamp));
+    rb_hash_aset(hash, ID2SYM(rb_intern("chip")),      UINT2NUM(reportQueue[qReadPos].chip));
+    rb_hash_aset(hash, ID2SYM(rb_intern("gpio")),      UINT2NUM(reportQueue[qReadPos].gpio));
+    rb_hash_aset(hash, ID2SYM(rb_intern("level")),     UINT2NUM(reportQueue[qReadPos].level));
+    rb_hash_aset(hash, ID2SYM(rb_intern("flags")),     UINT2NUM(reportQueue[qReadPos].flags));
+    popped = true;
+  }
+  pthread_mutex_unlock(&queueLock);
+
+  if (popped){
+    return hash;
+  } else {
+    return Qnil;
+  }
+}
+
 static VALUE tx_busy(VALUE self, VALUE handle, VALUE gpio, VALUE kind) {
   int result = lgTxBusy(NUM2INT(handle), NUM2INT(gpio), NUM2INT(kind));
   return INT2NUM(result);
@@ -119,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");
@@ -130,6 +313,9 @@ void Init_lgpio(void) {
   rb_define_const(mLGPIO, "SET_PULL_UP",      INT2NUM(LG_SET_PULL_UP));
   rb_define_const(mLGPIO, "SET_PULL_DOWN",    INT2NUM(LG_SET_PULL_DOWN));
   rb_define_const(mLGPIO, "SET_PULL_NONE",    INT2NUM(LG_SET_PULL_NONE));
+  rb_define_const(mLGPIO, "RISING_EDGE",      INT2NUM(LG_RISING_EDGE));
+  rb_define_const(mLGPIO, "FALLING_EDGE",     INT2NUM(LG_FALLING_EDGE));
+  rb_define_const(mLGPIO, "BOTH_EDGES",       INT2NUM(LG_BOTH_EDGES));
   rb_define_singleton_method(mLGPIO, "chip_open",          chip_open,         1);
   rb_define_singleton_method(mLGPIO, "chip_close",         chip_close,        1);
   rb_define_singleton_method(mLGPIO, "gpio_free",          gpio_free,         2);
@@ -145,6 +331,12 @@ void Init_lgpio(void) {
   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);
+
   // PWM / Servo / Wave
   rb_define_const(mLGPIO, "TX_PWM", INT2NUM(LG_TX_PWM));
   rb_define_const(mLGPIO, "TX_WAVE",INT2NUM(LG_TX_WAVE));
@@ -154,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.1"
+  VERSION = "0.1.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.3
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 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,8 +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
@@ -54,7 +63,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.5.9
+rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
 summary: lgpio (lg) bindings for Ruby