lgpio 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d173e84c707ec6e3d84715dbc7c56287a22d735fbbf118adc4d3b602513b852e
-  data.tar.gz: cb8d9acbdc1ed6da8fe9f037f8b837ee989b50d48b173980165b34e5c19d9b92
+  metadata.gz: 4bb351b8041dc3f5e78ed92128c3c971cf3f9e35d247a71e8d4ce56acec87f32
+  data.tar.gz: a4df4836decc51de97ad16093bbd19e649cd02b675d6511c601feddde0cded66
 SHA512:
-  metadata.gz: 4959700837149d70e16f550cbd02e13d03b4507ec1b50910c45bf7809e2c711547939ad50d2ba559c0b167befb6c670202e5de371bbe40bf764032d580e94830
-  data.tar.gz: 360a46aa061edb191ce80f67be784ac4edae21d7126cb4e05c3ce3812d416d2daa6f804ecfa532c790637d51f63010e01a07277971897fa26d7442f1c581a251
+  metadata.gz: f94daeeaba65d22c4ee2e0205a9399f18f886cc5f42e15f53a4991381756b7a33d97d29113918b809b6ff96d7900a327ee26d441d9249e86020cee7c21c34765
+  data.tar.gz: 367559fcd9750f88e728b80836c3dfa7d9273dcb2c734bc67faed29b23e177fc03e9e18df9678533907f3ddbe85be5d4d443a5d45404a03322ac09e586827e11

data/README.md

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

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/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,50 @@ static VALUE group_write(VALUE self, VALUE handle, VALUE gpio, VALUE bits, VALUE
   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);
@@ -130,6 +181,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);
@@ -144,6 +198,11 @@ 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_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));

data/lib/lgpio/version.rb

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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-05-03 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
@@ -28,6 +28,8 @@ files:
 - 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
@@ -54,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