lgpio 0.1.6 → 0.1.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ba4963055ec58ea685427a0c9395eedfbc20cf0159df764edbd3b735dd7ce40
-  data.tar.gz: b4149669d2ac089120582d09db4ab6d0e9bb45f8c93e22a62164272f9150c758
+  metadata.gz: 3007d43d8623a895efdcfb2089ccc3c9105bde952af5095d904019d2df56eaaf
+  data.tar.gz: 8aa7f8ecf78eff10e04deb2bc5a5732b939cbbaa99f7b4f578dd8320a7634fb7
 SHA512:
-  metadata.gz: 9e3397df71dadb44d9ebfb96d6732d9ba211f9dc5a530b96747e7ec2ee93e22b6412218f61938560864c10208fdc60609b93c18707ca67332c2a8800e880d21c
-  data.tar.gz: 7ebd239afcd78e16ea893943f1e226b06e68c9b0b2cf4c3a98acebe3f23a33e044fa51c1309b1779ac5415877be8512b78cff651e48a87fc0fe860ef2405531f
+  metadata.gz: 93cc1be6fcafd45e98a11272f608241adc2c809f0ff6d71333a63f93453bb34fba4a75155cb973c06407b6cea281fbdd934664970077a1608718f0f218eb49cd
+  data.tar.gz: f94f8859d0b7c3999687263a54979472fd73df50c0a3e09319aeb908c3b4e7de1bac458d97478f0ddeba19e4fe10d061c57e9331fc6910f386101315f4d087d5

data/examples/{i2c_bitbang_search.rb → i2c_bb_search.rb}

@@ -5,9 +5,8 @@ SCL_PIN   = 228
 SDA_PIN   = 270
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.i2c_bb_claim(chip_handle, SCL_PIN, SDA_PIN)
-
-devices = LGPIO.i2c_bb_search(chip_handle, SCL_PIN, SDA_PIN)
+i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+devices = i2c_bb.search
 
 if devices.empty?
   puts "No devices found on I2C bus"

data/examples/pwm_hw_bench.rb

@@ -0,0 +1,20 @@
+require 'lgpio'
+#
+# Writing directly to a hardware PWM channel.
+# Arguments in order are:
+#   pwmchip index (X in /sys/class/pwm/pwmchipX/)
+#   PWM channel on the chip (Y in /sys/class/pwm/pwmchipX/pwmY)
+#   period: given in nanoseconds
+#   OR frequency: given in Hz
+#
+pwm_out = LGPIO::HardwarePWM.new(0, 1, period: 20_000_000)
+
+RUNS = 250_000
+start = Time.now
+RUNS.times do
+  pwm_out.duty_us = 1000
+end
+finish = Time.now
+
+wps = RUNS / (finish - start)
+puts "Hardware PWM writes per second: #{wps.round(2)}"

data/examples/{spi_bitbang_ssd1306_bench.rb → spi_bb_ssd1306_bench.rb}

@@ -43,7 +43,7 @@ LGPIO.chip_close(chip_handle)
 
 fps = FRAME_COUNT / (finish - start)
 # Also calculate C calls per second, using roughly 20 calls per byte written.
-data_calls = START_ARRAY.length + ((PATTERN_1.length + PATTERN_2.length) / 2) * 20
+data_calls = (START_ARRAY.length + (PATTERN_1.length + PATTERN_2.length) / 2) * 20
 # Add DC, SELECT and clock idle calls.
 total_calls  = data_calls + 8
 cps = ((total_calls * fps) / 1000.0).round

data/ext/lgpio/lgpio.c

@@ -3,13 +3,19 @@
 #include <stdio.h>
 #include <time.h>
 
-// Set up a queue for up to 2**16 GPIO reports.
+/*****************************************************************************/
+/*                           GPIO REPORT QUEUE                               */
+/*****************************************************************************/
 static pthread_mutex_t queueLock;
+// Set up a queue for up to 2**16 GPIO reports.
 #define QUEUE_LENGTH UINT16_MAX + 1
 static lgGpioReport_t reportQueue[QUEUE_LENGTH];
 static uint16_t qWritePos = 1;
 static uint16_t qReadPos  = 0;
 
+/*****************************************************************************/
+/*                             TIMING HELPERS                                */
+/*****************************************************************************/
 static uint64_t nanoDiff(const struct timespec *event2, const struct timespec *event1) {
   uint64_t event2_ns = (uint64_t)event2->tv_sec * 1000000000LL + event2->tv_nsec;
   uint64_t event1_ns = (uint64_t)event1->tv_sec * 1000000000LL + event1->tv_nsec;
@@ -36,6 +42,9 @@ static void microDelay(uint64_t micros) {
   nanoDelay(micros * 1000);
 }
 
+/*****************************************************************************/
+/*                              CHIP & GPIO                                 */
+/*****************************************************************************/
 static VALUE chip_open(VALUE self, VALUE gpio_dev) {
   int result = lgGpiochipOpen(NUM2INT(gpio_dev));
   return INT2NUM(result);
@@ -162,103 +171,9 @@ static VALUE gpio_get_report(VALUE self){
   return (popped) ? hash : Qnil;
 }
 
-static VALUE gpio_read_ultrasonic(VALUE self, VALUE rbHandle, VALUE rbTrigger, VALUE rbEcho, VALUE rbTriggerTime) {
-  int handle            = NUM2UINT(rbHandle);
-  int trigger           = NUM2UINT(rbTrigger);
-  int echo              = NUM2UINT(rbEcho);
-  uint32_t triggerTime  = NUM2UINT(rbTriggerTime);
-  struct timespec start;
-  struct timespec now;
-  bool echoSeen = false;
-
-  // Pull down avoids false readings if disconnected.
-  lgGpioClaimInput(handle, LG_SET_PULL_DOWN, echo);
-
-  // Initial pulse on the triger pin.
-  lgGpioClaimOutput(handle, LG_SET_PULL_NONE, trigger, 0);
-  microDelay(5);
-  lgGpioWrite(handle, trigger, 1);
-  microDelay(triggerTime);
-  lgGpioWrite(handle, trigger, 0);
-
-  clock_gettime(CLOCK_MONOTONIC, &start);
-  now = start;
-
-  // Wait for echo to go high, up to 25,000 us after trigger.
-  while(nanoDiff(&now, &start) < 25000000){
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    if (lgGpioRead(handle, echo) == 1) {
-      echoSeen = true;
-      start = now;
-      break;
-    }
-  }
-  if (!echoSeen) return Qnil;
-
-  // Wait for echo to go low again, up to 25,000 us after echo start.
-  while(nanoDiff(&now, &start) < 25000000){
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    if (lgGpioRead(handle, echo) == 0) break;
-  }
-
-  // High pulse time in microseconds.
-  return INT2NUM(round(nanoDiff(&now, &start) / 1000.0));
-}
-
-static VALUE gpio_read_pulses_us(VALUE self, VALUE rbHandle, VALUE rbGPIO, VALUE rbReset_us, VALUE rbResetLevel, VALUE rbLimit, VALUE rbTimeout_ms) {
-  // C values
-  int handle          = NUM2INT(rbHandle);
-  int gpio            = NUM2INT(rbGPIO);
-  uint32_t reset_us   = NUM2UINT(rbReset_us);
-  uint8_t  resetLevel = NUM2UINT(rbResetLevel);
-  uint32_t limit      = NUM2UINT(rbLimit);
-  uint64_t timeout_ns = NUM2UINT(rbTimeout_ms) * 1000000;
-
-  // State setup
-  uint64_t pulses_ns[limit];
-  uint32_t pulseIndex = 0;
-  int      gpioState;
-  struct timespec start;
-  struct timespec lastPulse;
-  struct timespec now;
-
-  // Perform reset
-  if (reset_us > 0) {
-    int result = lgGpioClaimOutput(handle, LG_SET_PULL_NONE, gpio, resetLevel);
-    if (result < 0) return NUM2INT(result);
-    microDelay(reset_us);
-  }
-
-  // Initialize timing
-  clock_gettime(CLOCK_MONOTONIC, &start);
-  lastPulse = start;
-  now       = start;
-
-  // Switch to input and read initial state
-  lgGpioClaimInput(handle, LG_SET_PULL_NONE, gpio);
-  gpioState = lgGpioRead(handle, gpio);
-
-  // Read pulses in nanoseconds
-  while ((nanoDiff(&now, &start) < timeout_ns) && (pulseIndex < limit)) {
-    clock_gettime(CLOCK_MONOTONIC, &now);
-    if (lgGpioRead(handle, gpio) != gpioState) {
-      pulses_ns[pulseIndex] = nanoDiff(&now, &lastPulse);
-      lastPulse = now;
-      gpioState = gpioState ^ 0b1;
-      pulseIndex++;
-    }
-  }
-
-  // Return Ruby array of pulse as microseconds
-  if (pulseIndex == 0) return Qnil;
-  VALUE retArray = rb_ary_new2(pulseIndex);
-  for(int i=0; i<pulseIndex; i++){
-    uint32_t pulse_us = round(pulses_ns[i] / 1000.0);
-    rb_ary_store(retArray, i, UINT2NUM(pulse_us));
-  }
-  return retArray;
-}
-
+/*****************************************************************************/
+/*                          SOFTWARE PWM & WAVE                              */
+/*****************************************************************************/
 static VALUE tx_busy(VALUE self, VALUE handle, VALUE gpio, VALUE kind) {
   int result = lgTxBusy(NUM2INT(handle), NUM2INT(gpio), NUM2INT(kind));
   return INT2NUM(result);
@@ -302,6 +217,9 @@ static VALUE tx_wave(VALUE self, VALUE handle, VALUE lead_gpio, VALUE pulses) {
   return INT2NUM(result);
 }
 
+/*****************************************************************************/
+/*                        HARDWARE PWM OOK WAVE                              */
+/*****************************************************************************/
 static VALUE tx_wave_ook(VALUE self, VALUE dutyPath, VALUE dutyString, VALUE pulses) {
   // NOTE: This uses hardware PWM, NOT the lgpio software PWM/wave interface.
   // The Ruby class LGPIO::HardwarePWM should have already set the PWM carrier frequency.
@@ -343,6 +261,9 @@ static VALUE tx_wave_ook(VALUE self, VALUE dutyPath, VALUE dutyString, VALUE pul
   fclose(dutyFile);
 }
 
+/*****************************************************************************/
+/*                             HARDWARE I2C                                  */
+/*****************************************************************************/
 static VALUE i2c_open(VALUE self, VALUE i2cDev, VALUE i2cAddr, VALUE i2cFlags){
   int handle = lgI2cOpen(NUM2INT(i2cDev), NUM2INT(i2cAddr), NUM2INT(i2cFlags));
   return INT2NUM(handle);
@@ -406,6 +327,9 @@ static VALUE i2c_zip(VALUE self, VALUE handle, VALUE txArray, VALUE rb_rxCount){
   return retArray;
 }
 
+/*****************************************************************************/
+/*                             HARDWARE SPI                                  */
+/*****************************************************************************/
 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);
@@ -506,32 +430,108 @@ static VALUE spi_ws2812_write(VALUE self, VALUE handle, VALUE pixelArray){
 }
 
 /*****************************************************************************/
-/*                                 ONE WIRE                                  */
+/*                           BIT-BANG PULSE INPUT                            */
 /*****************************************************************************/
-static uint8_t bitReadU64(uint64_t* b, uint8_t i) {
-  return ((*b >> i) & 0b1);
-}
+static VALUE gpio_read_ultrasonic(VALUE self, VALUE rbHandle, VALUE rbTrigger, VALUE rbEcho, VALUE rbTriggerTime) {
+  int handle            = NUM2UINT(rbHandle);
+  int trigger           = NUM2UINT(rbTrigger);
+  int echo              = NUM2UINT(rbEcho);
+  uint32_t triggerTime  = NUM2UINT(rbTriggerTime);
+  struct timespec start;
+  struct timespec now;
+  bool echoSeen = false;
 
-static void bitWriteU64(uint64_t* b, uint8_t i, uint8_t v) {
-  if (v == 0) {
-    *b &= ~(1ULL << i);
-  } else {
-    *b |=  (1ULL << i);
+  // Pull down avoids false readings if disconnected.
+  lgGpioClaimInput(handle, LG_SET_PULL_DOWN, echo);
+
+  // Initial pulse on the triger pin.
+  lgGpioClaimOutput(handle, LG_SET_PULL_NONE, trigger, 0);
+  microDelay(5);
+  lgGpioWrite(handle, trigger, 1);
+  microDelay(triggerTime);
+  lgGpioWrite(handle, trigger, 0);
+
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  now = start;
+
+  // Wait for echo to go high, up to 25,000 us after trigger.
+  while(nanoDiff(&now, &start) < 25000000){
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    if (lgGpioRead(handle, echo) == 1) {
+      echoSeen = true;
+      start = now;
+      break;
+    }
+  }
+  if (!echoSeen) return Qnil;
+
+  // Wait for echo to go low again, up to 25,000 us after echo start.
+  while(nanoDiff(&now, &start) < 25000000){
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    if (lgGpioRead(handle, echo) == 0) break;
   }
-}
 
-static uint8_t bitReadU8(uint8_t* b, uint8_t i) {
-  return (*b >> i) & 0b1;
+  // High pulse time in microseconds.
+  return INT2NUM(round(nanoDiff(&now, &start) / 1000.0));
 }
 
-static void bitWriteU8(uint8_t* b, uint8_t i, uint8_t v) {
-  if (v == 0) {
-    *b &= ~(1 << i);
-  } else {
-    *b |=  (1 << i);
+static VALUE gpio_read_pulses_us(VALUE self, VALUE rbHandle, VALUE rbGPIO, VALUE rbReset_us, VALUE rbResetLevel, VALUE rbLimit, VALUE rbTimeout_ms) {
+  // C values
+  int handle          = NUM2INT(rbHandle);
+  int gpio            = NUM2INT(rbGPIO);
+  uint32_t reset_us   = NUM2UINT(rbReset_us);
+  uint8_t  resetLevel = NUM2UINT(rbResetLevel);
+  uint32_t limit      = NUM2UINT(rbLimit);
+  uint64_t timeout_ns = NUM2UINT(rbTimeout_ms) * 1000000;
+
+  // State setup
+  uint64_t pulses_ns[limit];
+  uint32_t pulseIndex = 0;
+  int      gpioState;
+  struct timespec start;
+  struct timespec lastPulse;
+  struct timespec now;
+
+  // Perform reset
+  if (reset_us > 0) {
+    int result = lgGpioClaimOutput(handle, LG_SET_PULL_NONE, gpio, resetLevel);
+    if (result < 0) return NUM2INT(result);
+    microDelay(reset_us);
+  }
+
+  // Initialize timing
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  lastPulse = start;
+  now       = start;
+
+  // Switch to input and read initial state
+  lgGpioClaimInput(handle, LG_SET_PULL_NONE, gpio);
+  gpioState = lgGpioRead(handle, gpio);
+
+  // Read pulses in nanoseconds
+  while ((nanoDiff(&now, &start) < timeout_ns) && (pulseIndex < limit)) {
+    clock_gettime(CLOCK_MONOTONIC, &now);
+    if (lgGpioRead(handle, gpio) != gpioState) {
+      pulses_ns[pulseIndex] = nanoDiff(&now, &lastPulse);
+      lastPulse = now;
+      gpioState = gpioState ^ 0b1;
+      pulseIndex++;
+    }
   }
+
+  // Return Ruby array of pulse as microseconds
+  if (pulseIndex == 0) return Qnil;
+  VALUE retArray = rb_ary_new2(pulseIndex);
+  for(int i=0; i<pulseIndex; i++){
+    uint32_t pulse_us = round(pulses_ns[i] / 1000.0);
+    rb_ary_store(retArray, i, UINT2NUM(pulse_us));
+  }
+  return retArray;
 }
 
+/*****************************************************************************/
+/*                       BIT BANG 1-WIRE HEPERS                              */
+/*****************************************************************************/
 static VALUE one_wire_bit_read(VALUE self, VALUE rbHandle, VALUE rbGPIO) {
   int handle  = NUM2INT(rbHandle);
   int gpio    = NUM2INT(rbGPIO);
@@ -598,167 +598,6 @@ static VALUE one_wire_reset(VALUE self, VALUE rbHandle, VALUE rbGPIO) {
   return UINT2NUM(presence);
 }
 
-/*****************************************************************************/
-/*                            BIT-BANG I2C                                   */
-/*****************************************************************************/
-static uint8_t sdaState = 1;
-
-static void i2c_bb_set_sda(int handle, int sda, uint8_t level) {
-  if (level == sdaState) return;
-  lgGpioWrite(handle, sda, level);
-  sdaState = level;
-}
-
-// Start condition is SDA then SCL going low, from both high.
-static void i2c_bb_start(int handle, int scl, int sda) {
-  lgGpioWrite(handle, sda, 0);
-  lgGpioWrite(handle, scl, 0);
-}
-
-// Stop condition is SDA going high, while SCL is also high.
-static void i2c_bb_stop(int handle, int scl, int sda) {
-  lgGpioWrite(handle, sda, 0);
-  lgGpioWrite(handle, scl, 1);
-  lgGpioWrite(handle, sda, 1);
-}
-
-static uint8_t i2c_bb_read_bit(int handle, int scl, int sda) {
-  uint8_t bit;
-  // Ensure SDA high before we pull SCL high.
-  i2c_bb_set_sda(handle, sda, 1);
-  lgGpioWrite(handle, scl, 1);
-  bit = lgGpioRead(handle, sda);
-  lgGpioWrite(handle, scl, 0);
-  return bit;
-}
-
-static void i2c_bb_write_bit(int handle, int scl, int sda, uint8_t bit) {
-  // Set SDA while SCL is low.
-  i2c_bb_set_sda(handle, sda, bit);
-  lgGpioWrite(handle, scl, 1);
-  lgGpioWrite(handle, scl, 0);
-}
-
-static uint8_t i2c_bb_read_byte(int handle, int scl, int sda, bool ack) {
-  uint8_t b;
-
-  // Receive MSB first.
-  for (int i=7; i>=0; i--) bitWriteU8(&b, i, i2c_bb_read_bit(handle, scl, sda));
-
-  // Send ACK or NACK and return byte.
-  if (ack) {
-    i2c_bb_write_bit(handle, scl, sda, 0);
-  } else {
-    i2c_bb_write_bit(handle, scl, sda, 1);
-  }
-  return b;
-}
-
-static int i2c_bb_write_byte(int handle, int scl, int sda, uint8_t b) {
-  // Send MSB first.
-  for (int i=7; i>=0; i--) i2c_bb_write_bit(handle, scl, sda, bitReadU8(&b, i));
-
-  // Return -1 for NACK, 0 for ACK.
-  return (i2c_bb_read_bit(handle, scl, sda) == 0) ? 0 : -1;
-}
-
-static VALUE i2c_bb_claim(VALUE self, VALUE rbHandle, VALUE rbSCL, VALUE rbSDA) {
-  int handle = NUM2INT(rbHandle);
-  int scl    = NUM2INT(rbSCL);
-  int sda    = NUM2INT(rbSDA);
-
-  // SCL is a driven output. SDA is open drain with pullup enabled.
-  lgGpioClaimOutput(handle, LG_SET_PULL_NONE, scl, 1);
-  lgGpioClaimOutput(handle, LG_SET_OPEN_DRAIN | LG_SET_PULL_UP, sda, 1);
-}
-
-static VALUE i2c_bb_search(VALUE self, VALUE rbHandle, VALUE rbSCL, VALUE rbSDA) {
-  int handle = NUM2INT(rbHandle);
-  int scl    = NUM2INT(rbSCL);
-  int sda    = NUM2INT(rbSDA);
-  int ack;
-  uint8_t present[128];
-  uint8_t presentCount = 0;
-  sdaState = 1;
-
-  // Only addresses from 0x08 to 0x77 are usable (8 to 127).
-  for (uint8_t addr = 0x08; addr < 0x78;  addr++) {
-    i2c_bb_start(handle, scl, sda);
-    ack = i2c_bb_write_byte(handle, scl, sda, ((addr << 1) & 0b11111110));
-    i2c_bb_stop(handle, scl, sda);
-    if (ack == 0){
-      present[addr] = 1;
-      presentCount++;
-    } else {
-      present[addr] = 0;
-    }
-  }
-  if (presentCount == 0) return Qnil;
-
-  VALUE retArray = rb_ary_new2(presentCount);
-  uint8_t i = 0;
-  for (uint8_t addr = 0x08; addr < 0x78;  addr++) {
-    if (present[addr] == 1) {
-      rb_ary_store(retArray, i, UINT2NUM(addr));
-      i++;
-    }
-  }
-  return retArray;
-}
-
-static VALUE i2c_bb_write(VALUE self, VALUE rbHandle, VALUE rbSCL, VALUE rbSDA, VALUE rbAddress, VALUE txArray) {
-  int handle = NUM2INT(rbHandle);
-  int scl    = NUM2INT(rbSCL);
-  int sda    = NUM2INT(rbSDA);
-  uint8_t address      = NUM2CHR(rbAddress);
-  uint8_t writeAddress = (address << 1);
-  sdaState = 1;
-
-  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);
-  }
-
-  i2c_bb_start(handle, scl, sda);
-  i2c_bb_write_byte(handle, scl, sda, writeAddress);
-  for (int i=0; i<count; i++) i2c_bb_write_byte(handle, scl, sda, txBuf[i]);
-  i2c_bb_stop(handle, scl, sda);
-}
-
-static VALUE i2c_bb_read(VALUE self, VALUE rbHandle, VALUE rbSCL, VALUE rbSDA, VALUE rbAddress, VALUE rbCount) {
-  int handle = NUM2INT(rbHandle);
-  int scl    = NUM2INT(rbSCL);
-  int sda    = NUM2INT(rbSDA);
-  uint8_t address      = NUM2CHR(rbAddress);
-  uint8_t readAddress  = (address << 1) | 0b00000001;
-  sdaState = 1;
-
-  int count = NUM2INT(rbCount);
-  uint8_t rxBuf[count];
-
-  i2c_bb_start(handle, scl, sda);
-  int ack = i2c_bb_write_byte(handle, scl, sda, readAddress);
-  // Device with this address not present on the bus.
-  if (ack != 0) return Qnil;
-
-  // Read and ACK for all but the last byte.
-  int pos = 0;
-  while(pos < count-1) {
-    rxBuf[pos] = i2c_bb_read_byte(handle, scl, sda, true);
-    pos++;
-  }
-  rxBuf[pos] = i2c_bb_read_byte(handle, scl, sda, false);
-  i2c_bb_stop(handle, scl, sda);
-
-  VALUE retArray = rb_ary_new2(count);
-  for(int i=0; i<count; i++) rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
-  return retArray;
-}
-
 /*****************************************************************************/
 /*                           EXTENSION INIT                                  */
 /*****************************************************************************/
@@ -798,10 +637,6 @@ void Init_lgpio(void) {
   rb_define_singleton_method(mLGPIO, "gpio_start_reporting",  gpio_start_reporting,  0);
   rb_define_singleton_method(mLGPIO, "gpio_get_report",       gpio_get_report,       0);
 
-  // Pulse Input
-  rb_define_singleton_method(mLGPIO, "gpio_read_ultrasonic",  gpio_read_ultrasonic,  4);
-  rb_define_singleton_method(mLGPIO, "gpio_read_pulses_us",   gpio_read_pulses_us,   6);
-
   // Soft PWM / Wave
   rb_define_const(mLGPIO, "TX_PWM", INT2NUM(LG_TX_PWM));
   rb_define_const(mLGPIO, "TX_WAVE",INT2NUM(LG_TX_WAVE));
@@ -813,6 +648,10 @@ void Init_lgpio(void) {
   // Don't use this. Servo will jitter.
   rb_define_singleton_method(mLGPIO, "tx_servo", tx_servo, 6);
 
+  // Hardware PWM waves for on-off-keying.
+  VALUE cHardwarePWM = rb_define_class_under(mLGPIO, "HardwarePWM", rb_cObject);
+  rb_define_method(cHardwarePWM, "tx_wave_ook", tx_wave_ook, 3);
+
   // I2C
   rb_define_singleton_method(mLGPIO, "i2c_open",           i2c_open,          3);
   rb_define_singleton_method(mLGPIO, "i2c_close",          i2c_close,         1);
@@ -828,18 +667,12 @@ void Init_lgpio(void) {
   rb_define_singleton_method(mLGPIO, "spi_xfer",           spi_xfer,          2);
   rb_define_singleton_method(mLGPIO, "spi_ws2812_write",   spi_ws2812_write,  2);
 
-  // Hardware PWM waves for on-off-keying.
-  VALUE cHardwarePWM = rb_define_class_under(mLGPIO, "HardwarePWM", rb_cObject);
-  rb_define_method(cHardwarePWM, "tx_wave_ook", tx_wave_ook, 3);
+  // Bit-Bang Pulse Input
+  rb_define_singleton_method(mLGPIO, "gpio_read_ultrasonic",  gpio_read_ultrasonic,  4);
+  rb_define_singleton_method(mLGPIO, "gpio_read_pulses_us",   gpio_read_pulses_us,   6);
 
-  // Bit-banged 1-Wire
+  // Bit-bang 1-Wire Helpers
   rb_define_singleton_method(mLGPIO, "one_wire_bit_read",   one_wire_bit_read,  2);
   rb_define_singleton_method(mLGPIO, "one_wire_bit_write",  one_wire_bit_write, 3);
   rb_define_singleton_method(mLGPIO, "one_wire_reset",      one_wire_reset,     2);
-
-  // Bit-banged I2C
-  rb_define_singleton_method(mLGPIO, "i2c_bb_claim",    i2c_bb_claim,    3);
-  rb_define_singleton_method(mLGPIO, "i2c_bb_search",   i2c_bb_search,   3);
-  rb_define_singleton_method(mLGPIO, "i2c_bb_write",    i2c_bb_write,    5);
-  rb_define_singleton_method(mLGPIO, "i2c_bb_read",     i2c_bb_read,     5);
 }

data/lgpio.gemspec

@@ -4,8 +4,8 @@ Gem::Specification.new do |s|
   s.name        = 'lgpio'
   s.version     = LGPIO::VERSION
   s.licenses    = ['MIT']
-  s.summary     = "lgpio (lg) bindings for Ruby"
-  s.description = "Use GPIO / PWM / I2C / SPI / UART on Linux SBCs in Ruby"
+  s.summary     = "Use Linux GPIO, I2C, SPI and PWM in Ruby"
+  s.description = "Use Linux GPIO, I2C, SPI and PWM in Ruby"
 
   s.authors     = ["vickash"]
   s.email       = 'mail@vickash.com'

data/lib/lgpio/spi_bitbang.rb

@@ -16,6 +16,10 @@ module LGPIO
       initialize_pins
     end
 
+    def config
+      @config ||= { handle: handle, clock: clock, input: input, output: output }
+    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

data/lib/lgpio/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.6
+  version: 0.1.8
 platform: ruby
 authors:
 - vickash
@@ -10,7 +10,7 @@ bindir: bin
 cert_chain: []
 date: 2024-09-19 00:00:00.000000000 Z
 dependencies: []
-description: Use GPIO / PWM / I2C / SPI / UART on Linux SBCs in Ruby
+description: Use Linux GPIO, I2C, SPI and PWM in Ruby
 email: mail@vickash.com
 executables: []
 extensions:
@@ -21,37 +21,36 @@ files:
 - LICENSE
 - README.md
 - Rakefile
-- examples/bench_in.rb
-- examples/bench_out.rb
-- examples/blink.rb
 - examples/dht.rb
-- examples/group_in.rb
-- examples/group_out.rb
+- examples/gpio_bench_in.rb
+- examples/gpio_bench_out.rb
+- examples/gpio_blink.rb
+- examples/gpio_group_in.rb
+- examples/gpio_group_out.rb
+- examples/gpio_momentary.rb
+- examples/gpio_reports.rb
+- examples/gpio_rotary_encoder.rb
+- examples/gpio_rotary_encoder_led.rb
+- examples/gpio_wave.rb
 - examples/hcsr04.rb
-- examples/i2c_aht10.rb
-- examples/i2c_aht10_zip.rb
-- examples/i2c_bitbang-rb_aht10.rb
-- examples/i2c_bitbang-rb_ssd1306_bench.rb
-- examples/i2c_bitbang_aht10.rb
-- examples/i2c_bitbang_search.rb
-- examples/i2c_bitbang_ssd1306_bench.rb
-- examples/i2c_ssd1306_bench.rb
+- examples/i2c_bb_aht10.rb
+- examples/i2c_bb_search.rb
+- examples/i2c_bb_ssd1306_bench.rb
+- examples/i2c_hw_aht10.rb
+- examples/i2c_hw_aht10_zip.rb
+- examples/i2c_hw_ssd1306_bench.rb
 - examples/infrared.rb
-- examples/momentary.rb
 - examples/one_wire_ds18b20.rb
 - examples/one_wire_search.rb
-- examples/pwm.rb
-- examples/reports.rb
-- examples/rotary_encoder.rb
-- examples/rotary_encoder_led.rb
-- examples/servo.rb
-- examples/spi_bitbang_loopback.rb
-- examples/spi_bitbang_ssd1306_bench.rb
-- examples/spi_bitbang_ssd1306_sim_bench.rb
-- examples/spi_loopback.rb
-- examples/spi_ws2812.rb
-- examples/spi_ws2812_bounce.rb
-- examples/wave.rb
+- examples/pwm_hw_bench.rb
+- examples/pwm_hw_servo.rb
+- examples/pwm_sw.rb
+- examples/spi_bb_loopback.rb
+- examples/spi_bb_sim_bench.rb
+- examples/spi_bb_ssd1306_bench.rb
+- examples/spi_hw_loopback.rb
+- examples/spi_hw_ws2812.rb
+- examples/spi_hw_ws2812_bounce.rb
 - ext/lgpio/extconf.rb
 - ext/lgpio/lgpio.c
 - lgpio.gemspec
@@ -86,5 +85,5 @@ requirements: []
 rubygems_version: 3.5.16
 signing_key:
 specification_version: 4
-summary: lgpio (lg) bindings for Ruby
+summary: Use Linux GPIO, I2C, SPI and PWM in Ruby
 test_files: []

data/examples/i2c_bitbang_aht10.rb

@@ -1,40 +0,0 @@
-require 'lgpio'
-
-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]
-
-GPIO_CHIP = 0
-SCL_PIN   = 228
-SDA_PIN   = 270
-ADDRESS   = 0x38
-
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.i2c_bb_claim(chip_handle, SCL_PIN, SDA_PIN)
-
-# Startup sequence
-sleep(POWER_ON_DELAY)
-LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, SOFT_RESET)
-sleep(RESET_DELAY)
-LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, INIT_AND_CALIBRATE)
-sleep(COMMAND_DELAY)
-
-# Read and close
-LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, START_MEASUREMENT)
-sleep(MEASURE_DELAY)
-bytes = LGPIO.i2c_bb_read(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, DATA_LENGTH)
-
-# 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_bitbang_ssd1306_bench.rb

@@ -1,35 +0,0 @@
-require 'lgpio'
-
-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]
-PATTERN_1   = [64] + Array.new(1024) { 0b00110011 }
-PATTERN_2   = [64] + Array.new(1024) { 0b11001100 }
-
-GPIO_CHIP = 0
-SCL_PIN   = 228
-SDA_PIN   = 270
-ADDRESS   = 0x3C
-
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-LGPIO.i2c_bb_claim(chip_handle, SCL_PIN, SDA_PIN)
-
-LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, INIT_ARRAY)
-FRAME_COUNT = 400
-
-start = Time.now
-(FRAME_COUNT / 2).times do
-  LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, START_ARRAY)
-  LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, PATTERN_1)
-  LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, START_ARRAY)
-  LGPIO.i2c_bb_write(chip_handle, SCL_PIN, SDA_PIN, ADDRESS, PATTERN_2)
-end
-finish = Time.now
-
-LGPIO.chip_close(chip_handle)
-
-fps = FRAME_COUNT / (finish - start)
-# Also calculate C calls per second, using roughly 23 calls per byte written.
-cps = (START_ARRAY.length + ((PATTERN_1.length + PATTERN_2.length) / 2) + 2) * 23 * fps
-cps = (cps / 1000.0).round
-
-puts "SSD1306 benchmark result: #{fps.round(2)} fps | #{cps}k C calls/s"