lgpio 0.1.0 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3694843b060710d0fdf63c790b2857cd00bb37943fb80b52b4bb0e884c9eac63
-  data.tar.gz: 5749c5dbcaca251af6f5b2c6c3d189bcf1226f67ebabfc0dd418dee49361da77
+  metadata.gz: 4bb351b8041dc3f5e78ed92128c3c971cf3f9e35d247a71e8d4ce56acec87f32
+  data.tar.gz: a4df4836decc51de97ad16093bbd19e649cd02b675d6511c601feddde0cded66
 SHA512:
-  metadata.gz: e7cd82024168e24f5a776a39b364a7c9f2432de7de6d1966517c686d04acaddf338186074b7b7597051e9521bc93115292223e66a7fa34b2fcf7bb02090ae0ae
-  data.tar.gz: 6855f0811581f7c50803cf1372a9d3927399e547b9d3b9f05dd6162106949d3793d9ea40ee50d5253b9d3c252ed137bfe0859cf7bc38d00a3a2686e64d4be82e
+  metadata.gz: f94daeeaba65d22c4ee2e0205a9399f18f886cc5f42e15f53a4991381756b7a33d97d29113918b809b6ff96d7900a327ee26d441d9249e86020cee7c21c34765
+  data.tar.gz: 367559fcd9750f88e728b80836c3dfa7d9273dcb2c734bc67faed29b23e177fc03e9e18df9678533907f3ddbe85be5d4d443a5d45404a03322ac09e586827e11

data/README.md

@@ -7,10 +7,10 @@ Ruby bindings for the [lgpio (lg)](https://github.com/joan2937/lg) C library, wh
 ### Progress:
 
 - [x] GPIO Read/Write
-- [ ] GPIO Group Read/Write
-- [ ] GPIO Callbacks
-- [ ] PWM
-- [ ] Wave
+- [x] GPIO Group Read/Write
+- [x] GPIO Alerts / Callbacks (read from a queue)
+- [x] PWM (software-timed)
+- [x] Wave (software-timed)
 - [ ] I2C
 - [ ] SPI
 - [ ] Serial

data/examples/bench_in.rb

@@ -1,8 +1,8 @@
 require 'lgpio'
 
 GPIO_CHIP = 0
-PIN = 258
-COUNT = 1000000
+PIN       = 258
+COUNT     = 1000000
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP, PIN)
@@ -14,3 +14,6 @@ end
 t2 = Time.now
 
 puts "Reads per second: #{COUNT.to_f / (t2 - t1).to_f}"
+
+LGPIO.gpio_free(chip_handle, PIN)
+LGPIO.chip_close(chip_handle)

data/examples/bench_out.rb

@@ -1,8 +1,8 @@
 require 'lgpio'
 
 GPIO_CHIP = 0
-PIN = 260
-COUNT = 1000000
+PIN       = 260
+COUNT     = 1000000
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, PIN, LGPIO::LOW)
@@ -15,3 +15,6 @@ end
 t2 = Time.now
 
 puts "Toggles per second: #{COUNT.to_f / (t2 - t1).to_f}"
+
+LGPIO.gpio_free(chip_handle, PIN)
+LGPIO.chip_close(chip_handle)

data/examples/blink.rb

@@ -1,8 +1,8 @@
 require 'lgpio'
 
 GPIO_CHIP = 0
-LED = 260
-INTERVAL = 0.25
+LED       = 260
+INTERVAL  = 0.25
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
 LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, LED, LGPIO::LOW)

data/examples/group_in.rb

@@ -0,0 +1,18 @@
+
+require 'lgpio'
+
+GPIO_CHIP   = 0
+BUTTONS     = [258, 256]
+LEDS        = [260, 267]
+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)
+
+# The inverted (active-low) state of each button controls the corresponding LED.
+loop do
+  output_bits = LGPIO.group_read(chip_handle, BUTTONS[0]) ^ 0b11
+  LGPIO.group_write(chip_handle, LEDS[0], output_bits, 0b11)
+  sleep 0.001
+end

data/examples/group_out.rb

@@ -0,0 +1,27 @@
+require 'lgpio'
+
+GPIO_CHIP   = 0
+LEDS        = [260, 267]
+INIT_STATE  = [0, 0]
+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)
+
+# Convert us interval to seconds.
+interval = INTERVAL.to_f / 1_000_000
+
+# Alternate the LEDs each INTERVAL.
+TIMES.times do
+  # Last 2 args are bits to write, and write mask respectively.
+  LGPIO.group_write(chip_handle, LEDS[0], 0b01, 0b11)
+  sleep interval
+  LGPIO.group_write(chip_handle, LEDS[0], 0b10, 0b11)
+  sleep interval
+end
+
+# Turn them off and cleanup.
+LGPIO.group_write(chip_handle, LEDS[0], 0b00, 0b11)
+LGPIO.group_free(chip_handle, LEDS[0])
+LGPIO.chip_close(chip_handle)

data/examples/pwm.rb

@@ -0,0 +1,19 @@
+require 'lgpio'
+
+GPIO_CHIP   = 0
+LED         = 260
+PWM_FREQ    = 500
+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)
+
+# Seamless loop from 0-100 and back.
+duty_cycles = (0..100).to_a + (1..99).to_a.reverse
+
+# Pulse the LED up and down.
+duty_cycles.cycle do |d|
+  LGPIO.tx_pwm(chip_handle, LED, PWM_FREQ, d, PWM_OFFSET, PWM_CYCLES)
+  sleep 0.020
+end

data/examples/reports.rb

@@ -0,0 +1,18 @@
+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_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,51 @@
+#
+# 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_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, 0, LGPIO::BOTH_EDGES, PIN_B)
+
+# Switch pin setup
+LGPIO.gpio_claim_input(chip_handle, LGPIO::SET_PULL_UP,     PIN_SW)
+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/wave.rb

@@ -0,0 +1,32 @@
+require 'lgpio'
+
+GPIO_CHIP   = 0
+LEDS        = [260, 267]
+INIT_STATE  = [0, 0]
+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)
+
+# Generic pulse that updates both LED states (first element) each INTERVAL.
+generic_pulse = [ nil, 0b11, INTERVAL ]
+
+# Alternate the LEDs each INTERVAL.
+pulses = []
+TIMES.times do
+  pulses << generic_pulse.clone
+  pulses.last[0] = 0b01
+  pulses << generic_pulse.clone
+  pulses.last[0] = 0b10
+end
+# Turn them off at the end.
+pulses << [0b00, 0b11, 1000]
+
+# Add to wave queue.
+LGPIO.tx_wave(chip_handle, LEDS[0], pulses)
+
+# Wait for it to complete, then cleanup.
+sleep 0.010 while LGPIO.tx_busy(chip_handle, LEDS[0], LGPIO::TX_WAVE) == 1
+LGPIO.group_free(chip_handle, LEDS[0])
+LGPIO.chip_close(chip_handle)

data/ext/lgpio/lgpio.c

@@ -1,13 +1,20 @@
 #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);
 }
 
-static VALUE chip_close(VALUE self, VALUE gpio_dev) {
-  int result = lgGpiochipClose(NUM2INT(gpio_dev));
+static VALUE chip_close(VALUE self, VALUE handle) {
+  int result = lgGpiochipClose(NUM2INT(handle));
   return INT2NUM(result);
 }
 
@@ -21,6 +28,11 @@ static VALUE gpio_claim_input(VALUE self, VALUE handle, VALUE flags, VALUE gpio)
   return INT2NUM(result);
 }
 
+static VALUE gpio_free(VALUE self, VALUE handle, VALUE gpio) {
+  int result = lgGpioFree(NUM2INT(handle), NUM2INT(gpio));
+  return INT2NUM(result);
+}
+
 static VALUE gpio_read(VALUE self, VALUE handle, VALUE gpio) {
   int result = lgGpioRead(NUM2INT(handle), NUM2INT(gpio));
   return INT2NUM(result);
@@ -31,23 +43,174 @@ 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) {
+  int count = rb_array_len(gpios);
+  int lgGpios[count];
+  int i;
+  for(i=0; i<count; i++) {
+    lgGpios[i] = NUM2INT(rb_ary_entry(gpios, i));
+  }
+  int result = lgGroupClaimInput(NUM2INT(handle), NUM2INT(flags), count, lgGpios);
+  return INT2NUM(result);
+}
+
+static VALUE group_claim_output(VALUE self, VALUE handle, VALUE flags, VALUE gpios, VALUE levels) {
+  int count = rb_array_len(gpios);
+  int lgGpios[count];
+  int lgLevels[count];
+  int i;
+  for(i=0; i<count; i++) {
+    lgGpios[i]  = NUM2INT(rb_ary_entry(gpios, i));
+    lgLevels[i] = NUM2INT(rb_ary_entry(levels, i));
+  }
+  int result = lgGroupClaimOutput(NUM2INT(handle), NUM2INT(flags), count, lgGpios, lgLevels);
+  return INT2NUM(result);
+}
+
+static VALUE group_free(VALUE self, VALUE handle, VALUE gpio) {
+  int result = lgGroupFree(NUM2INT(handle), NUM2INT(gpio));
+  return INT2NUM(result);
+}
+
+static VALUE group_read(VALUE self, VALUE handle, VALUE gpio) {
+  uint64_t result;
+  lgGroupRead(NUM2INT(handle), NUM2INT(gpio), &result);
+  return UINT2NUM(result);
+}
+
+static VALUE group_write(VALUE self, VALUE handle, VALUE gpio, VALUE bits, VALUE mask) {
+  int result = lgGroupWrite(NUM2INT(handle), NUM2INT(gpio), NUM2UINT(bits), NUM2UINT(mask));
+  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);
+}
+
+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);
+}
+
+static VALUE tx_room(VALUE self, VALUE handle, VALUE gpio, VALUE kind) {
+  int result = lgTxRoom(NUM2INT(handle), NUM2INT(gpio), NUM2INT(kind));
+  return INT2NUM(result);
+}
+
+static VALUE tx_pulse(VALUE self, VALUE handle, VALUE gpio, VALUE on, VALUE off, VALUE offset, VALUE cycles) {
+  int result = lgTxPulse(NUM2INT(handle), NUM2INT(gpio), NUM2INT(on), NUM2INT(off), NUM2INT(offset), NUM2INT(cycles));
+  return INT2NUM(result);
+}
+
+static VALUE tx_pwm(VALUE self, VALUE handle, VALUE gpio, VALUE freq, VALUE duty, VALUE offset, VALUE cycles) {
+  int result = lgTxPwm(NUM2INT(handle), NUM2INT(gpio), NUM2INT(freq), NUM2INT(duty), NUM2INT(offset), NUM2INT(cycles));
+  return INT2NUM(result);
+}
+
+static VALUE tx_servo(VALUE self, VALUE handle, VALUE gpio, VALUE width, VALUE freq, VALUE offset, VALUE cycles) {
+  int result = lgTxServo(NUM2INT(handle), NUM2INT(gpio), NUM2INT(width), NUM2INT(freq), NUM2INT(offset), NUM2INT(cycles));
+  return INT2NUM(result);
+}
+
+static VALUE tx_wave(VALUE self, VALUE handle, VALUE lead_gpio, VALUE pulses) {
+  // Copy Ruby array to array of lgPulse_t.
+  int       pulseCount = rb_array_len(pulses);
+  lgPulse_t pulsesOut[pulseCount];
+  VALUE     rbPulse;
+  int       i;
+  for(i=0; i<pulseCount; i++) {
+    rbPulse            = rb_ary_entry(pulses, i);
+    pulsesOut[i].bits  = NUM2UINT(rb_ary_entry(rbPulse, 0));
+    pulsesOut[i].mask  = NUM2UINT(rb_ary_entry(rbPulse, 1));
+    pulsesOut[i].delay = NUM2INT (rb_ary_entry(rbPulse, 2));
+  }
+
+  // Add it to wave queue.
+  int result = lgTxWave(NUM2INT(handle), NUM2INT(lead_gpio), pulseCount, pulsesOut);
+  return INT2NUM(result);
+}
+
 void Init_lgpio(void) {
   // Modules
   VALUE mLGPIO = rb_define_module("LGPIO");
 
-  // Constants
+  // Basics
   rb_define_const(mLGPIO, "SET_ACTIVE_LOW",   INT2NUM(LG_SET_ACTIVE_LOW));
   rb_define_const(mLGPIO, "SET_OPEN_DRAIN",   INT2NUM(LG_SET_OPEN_DRAIN));
   rb_define_const(mLGPIO, "SET_OPEN_SOURCE",  INT2NUM(LG_SET_OPEN_SOURCE));
   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));
-
-  // Methods
-  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_claim_input",   gpio_claim_input, 3);
+  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);
+  rb_define_singleton_method(mLGPIO, "gpio_claim_input",   gpio_claim_input,  3);
   rb_define_singleton_method(mLGPIO, "gpio_claim_output",  gpio_claim_output, 4);
-  rb_define_singleton_method(mLGPIO, "gpio_read",          gpio_read, 2);
-  rb_define_singleton_method(mLGPIO, "gpio_write",         gpio_write, 3);
+  rb_define_singleton_method(mLGPIO, "gpio_read",          gpio_read,         2);
+  rb_define_singleton_method(mLGPIO, "gpio_write",         gpio_write,        3);
+
+  // Grouped
+  rb_define_singleton_method(mLGPIO, "group_claim_input",   group_claim_input,  3);
+  rb_define_singleton_method(mLGPIO, "group_claim_output",  group_claim_output, 4);
+  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_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));
+  rb_define_singleton_method(mLGPIO, "tx_busy",  tx_busy,  3);
+  rb_define_singleton_method(mLGPIO, "tx_room",  tx_room,  3);
+  rb_define_singleton_method(mLGPIO, "tx_pulse", tx_pulse, 6);
+  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);
 }

data/lib/lgpio/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-04-24 00:00:00.000000000 Z
+date: 2024-07-31 00:00:00.000000000 Z
 dependencies: []
 description: Use GPIO / PWM / I2C / SPI / UART on Linux SBCs in Ruby
 email: mail@vickash.com
@@ -24,7 +24,13 @@ files:
 - examples/bench_in.rb
 - examples/bench_out.rb
 - examples/blink.rb
+- examples/group_in.rb
+- examples/group_out.rb
 - examples/momentary.rb
+- examples/pwm.rb
+- examples/reports.rb
+- examples/rotary_encoder.rb
+- examples/wave.rb
 - ext/lgpio/extconf.rb
 - ext/lgpio/lgpio.c
 - lgpio.gemspec
@@ -50,7 +56,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