lgpio 0.1.5 → 0.1.6

data/examples/spi_bitbang_ssd1306_bench.rb

@@ -0,0 +1,51 @@
+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   = Array.new(1024) { 0b00110011 }
+PATTERN_2   = Array.new(1024) { 0b11001100 }
+
+GPIO_CHIP   = 0
+CLOCK_PIN   = 17
+OUTPUT_PIN  = 27
+SELECT_PIN  = 22
+RESET_PIN   = 5
+DC_PIN      = 6
+
+# Initialize
+chip_handle = LGPIO.chip_open(GPIO_CHIP)
+spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, output: OUTPUT_PIN)
+LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, SELECT_PIN, LGPIO::HIGH)
+LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, RESET_PIN, LGPIO::LOW)
+LGPIO.gpio_claim_output(chip_handle, LGPIO::SET_PULL_NONE, DC_PIN, LGPIO::LOW)
+
+# OLED STARTUP
+LGPIO.gpio_write(chip_handle, RESET_PIN, 1)
+LGPIO.gpio_write(chip_handle, DC_PIN, 0)
+spi_bb.transfer(write: INIT_ARRAY, select: SELECT_PIN)
+
+FRAME_COUNT = 400
+
+start = Time.now
+(FRAME_COUNT / 2).times do
+  LGPIO.gpio_write(chip_handle, DC_PIN, 0)
+  spi_bb.transfer(write: START_ARRAY, select: SELECT_PIN)
+  LGPIO.gpio_write(chip_handle, DC_PIN, 1)
+  spi_bb.transfer(write: PATTERN_1, select: SELECT_PIN)
+  LGPIO.gpio_write(chip_handle, DC_PIN, 0)
+  spi_bb.transfer(write: START_ARRAY, select: SELECT_PIN)
+  LGPIO.gpio_write(chip_handle, DC_PIN, 1)
+  spi_bb.transfer(write: PATTERN_2, select: SELECT_PIN)
+end
+finish = Time.now
+
+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
+# Add DC, SELECT and clock idle calls.
+total_calls  = data_calls + 8
+cps = ((total_calls * fps) / 1000.0).round
+
+puts "SSD1306 benchmark result: #{fps.round(2)} fps | #{cps}k C calls/s"

data/examples/spi_bitbang_ssd1306_sim_bench.rb

@@ -0,0 +1,48 @@
+require 'lgpio'
+
+GPIO_CHIP   = 0
+CLOCK_PIN   = 17
+INPUT_PIN   = 22
+OUTPUT_PIN  = 27
+
+# Emulate data sent over I2C to a SSD1306 OLED, prepending its write address.
+START_ARRAY = [0x3C << 1] + [0, 33, 0, 127, 34, 0, 7]
+PATTERN_1   = [0x3C << 1] + [64] + Array.new(1179) { 0b00110011 }
+PATTERN_2   = [0x3C << 1] + [64] + Array.new(1179) { 0b11001100 }
+FRAME_COUNT = 400
+
+chip_handle = LGPIO.chip_open(GPIO_CHIP)
+spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, input: INPUT_PIN, output: OUTPUT_PIN)
+
+start = Time.now
+(FRAME_COUNT / 2).times do
+  spi_bb.transfer(write: START_ARRAY)
+  spi_bb.transfer(write: PATTERN_1)
+  spi_bb.transfer(write: START_ARRAY)
+  spi_bb.transfer(write: PATTERN_2)
+end
+finish = Time.now
+
+LGPIO.chip_close(chip_handle)
+
+fps = FRAME_COUNT / (finish - start)
+#
+# We want to calculate how many C calls were made per second, to compare with I2C:
+#  - SPI bytes are 8 bits on the wire, while I2C are 9 (8 data bits + ACK bit).
+#  - The I2C ACK should do 4 C API calls, while data bits on both buses need 3 calls.
+#  - This isn't always true. Because of the "lazy" optimization when setting the data pin
+#    in both protocols, and the line pattern being used, where the first bit of
+#    each byte is the inverse of the last bit of the previous byte, two things change:
+#    - Each I2C ACK is effecitvely 3 C calls. The data bit either before or after is always 1,
+#      eliminating a write to SDA.
+#    - For both buses, the "2 on, 2 off" patern means 8 data bits are only 20 C calls total.
+#  - So SPI is 20 for all pixel bytes, and I2C is 23 for all pixel bytes.
+#  - Ignores bit changes in the address and start bytes.
+#  - Ignore 10 calls per frame for I2C start/stop, and 2 calls per frame for SPI clock idle.
+#  - These are only 1% of total calls, so should be negligible.
+#  - Changing the line pattern WILL break this calculation.
+#
+cps = (START_ARRAY.length + ((PATTERN_1.length + PATTERN_2.length) / 2)) * 20 * fps
+cps = (cps / 1000.0).round
+
+puts "SSD1306 sim result: #{fps.round(2)} fps | #{cps}k C calls/s"

data/examples/wave.rb

@@ -1,7 +1,7 @@
 require 'lgpio'
 
 GPIO_CHIP   = 0
-LEDS        = [260, 267]
+LEDS        = [272, 258]
 INIT_STATE  = [0, 0]
 INTERVAL    = 250_000 # 250ms
 TIMES       = 10

data/ext/lgpio/lgpio.c

@@ -1,5 +1,7 @@
 #include <lgpio.h>
 #include <ruby.h>
+#include <stdio.h>
+#include <time.h>
 
 // Set up a queue for up to 2**16 GPIO reports.
 static pthread_mutex_t queueLock;
@@ -8,6 +10,32 @@ static lgGpioReport_t reportQueue[QUEUE_LENGTH];
 static uint16_t qWritePos = 1;
 static uint16_t qReadPos  = 0;
 
+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;
+  return event2_ns - event1_ns;
+}
+
+static uint64_t nanosSince(const struct timespec *event) {
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &now);
+  return nanoDiff(&now, event);
+}
+
+static void nanoDelay(uint64_t nanos) {
+  struct timespec refTime;
+  struct timespec now;
+  clock_gettime(CLOCK_MONOTONIC, &refTime);
+  now = refTime;
+  while(nanoDiff(&now, &refTime) < nanos) {
+    clock_gettime(CLOCK_MONOTONIC, &now);
+  }
+}
+
+static void microDelay(uint64_t micros) {
+  nanoDelay(micros * 1000);
+}
+
 static VALUE chip_open(VALUE self, VALUE gpio_dev) {
   int result = lgGpiochipOpen(NUM2INT(gpio_dev));
   return INT2NUM(result);
@@ -18,6 +46,11 @@ static VALUE chip_close(VALUE self, VALUE handle) {
   return INT2NUM(result);
 }
 
+static VALUE gpio_get_mode(VALUE self, VALUE handle, VALUE gpio) {
+  int result = lgGpioGetMode(NUM2INT(handle), NUM2INT(gpio));
+  return INT2NUM(result);
+}
+
 static VALUE gpio_claim_output(VALUE self, VALUE handle, VALUE flags, VALUE gpio, VALUE level) {
   int result = lgGpioClaimOutput(NUM2INT(handle), NUM2INT(flags), NUM2INT(gpio), NUM2INT(level));
   return INT2NUM(result);
@@ -93,13 +126,13 @@ static VALUE gpio_claim_alert(VALUE self, VALUE handle, VALUE flags, VALUE eFlag
   return INT2NUM(result);
 }
 
-void queue_gpio_reports(int count, lgGpioAlert_p events, void *data){
+static 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;
+    qWritePos++;
     // qReadPos is the LAST report read. If passing by 1, increment it too. Lose oldest data first.
-    if (qWritePos - qReadPos == 1) qReadPos += 1;
+    if (qWritePos - qReadPos == 1) qReadPos++;
   }
   pthread_mutex_unlock(&queueLock);
 }
@@ -126,11 +159,104 @@ static VALUE gpio_get_report(VALUE self){
   }
   pthread_mutex_unlock(&queueLock);
 
-  if (popped){
-    return hash;
-  } else {
-    return Qnil;
+  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;
 }
 
 static VALUE tx_busy(VALUE self, VALUE handle, VALUE gpio, VALUE kind) {
@@ -176,6 +302,47 @@ static VALUE tx_wave(VALUE self, VALUE handle, VALUE lead_gpio, VALUE pulses) {
   return INT2NUM(result);
 }
 
+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.
+  //
+  // Convert pulses from microseconds to nanoseconds.
+  uint32_t pulseCount = rb_array_len(pulses);
+  uint64_t nanoPulses[pulseCount];
+  for (int i=0; i<pulseCount; i++) {
+    nanoPulses[i] = NUM2UINT(rb_ary_entry(pulses, i)) * 1000;
+  }
+
+  // Prepare to write duty cycle.
+  const char *filePath = StringValueCStr(dutyPath);
+  FILE *dutyFile = fopen(filePath, "w");
+  if (dutyFile == NULL) {
+    VALUE errorMessage = rb_sprintf("Could not open PWM duty_cycle file: %s", filePath);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(errorMessage));
+  }
+  fclose(dutyFile);
+  const char *cDuty = StringValueCStr(dutyString);
+
+  // Toggle duty cycle between given value and 0, to modulate the PWM carrier.
+  for (int i=0; i<pulseCount; i++) {
+    if (i % 2 == 0) {
+      dutyFile = fopen(filePath, "w");
+      fputs(cDuty, dutyFile);
+      fclose(dutyFile);
+    } else {
+      dutyFile = fopen(filePath, "w");
+      fputs("0", dutyFile);
+      fclose(dutyFile);
+    }
+    // Wait for pulse time.
+    nanoDelay(nanoPulses[i]);
+  }
+  // Leave the pin low.
+  dutyFile = fopen(filePath, "w");
+  fputs("0", dutyFile);
+  fclose(dutyFile);
+}
+
 static VALUE i2c_open(VALUE self, VALUE i2cDev, VALUE i2cAddr, VALUE i2cFlags){
   int handle = lgI2cOpen(NUM2INT(i2cDev), NUM2INT(i2cAddr), NUM2INT(i2cFlags));
   return INT2NUM(handle);
@@ -338,6 +505,263 @@ static VALUE spi_ws2812_write(VALUE self, VALUE handle, VALUE pixelArray){
   return INT2NUM(result);
 }
 
+/*****************************************************************************/
+/*                                 ONE WIRE                                  */
+/*****************************************************************************/
+static uint8_t bitReadU64(uint64_t* b, uint8_t i) {
+  return ((*b >> i) & 0b1);
+}
+
+static void bitWriteU64(uint64_t* b, uint8_t i, uint8_t v) {
+  if (v == 0) {
+    *b &= ~(1ULL << i);
+  } else {
+    *b |=  (1ULL << i);
+  }
+}
+
+static uint8_t bitReadU8(uint8_t* b, uint8_t i) {
+  return (*b >> i) & 0b1;
+}
+
+static void bitWriteU8(uint8_t* b, uint8_t i, uint8_t v) {
+  if (v == 0) {
+    *b &= ~(1 << i);
+  } else {
+    *b |=  (1 << i);
+  }
+}
+
+static VALUE one_wire_bit_read(VALUE self, VALUE rbHandle, VALUE rbGPIO) {
+  int handle  = NUM2INT(rbHandle);
+  int gpio    = NUM2INT(rbGPIO);
+  uint8_t bit = 1;
+  struct timespec start;
+  struct timespec now;
+
+  // Start the read slot.
+  lgGpioWrite(handle, gpio, 0);
+  microDelay(1);
+  lgGpioWrite(handle, gpio, 1);
+
+  // Poll for 60us to see if pin goes low.
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  now = start;
+  while(nanoDiff(&now, &start) < 60000){
+    if (lgGpioRead(handle, gpio) == 0) bit = 0;
+    clock_gettime(CLOCK_MONOTONIC, &now);
+  }
+  return UINT2NUM(bit);
+}
+
+static VALUE one_wire_bit_write(VALUE self, VALUE rbHandle, VALUE rbGPIO, VALUE rbBit) {
+  int handle  = NUM2INT(rbHandle);
+  int gpio    = NUM2INT(rbGPIO);
+  uint8_t bit = NUM2CHR(rbBit);
+
+  // Write slot starts by going low for at least 1us.
+  lgGpioWrite(handle, gpio, 0);
+  microDelay(1);
+
+  // If 0, keep it low for the rest of the 60us write slot, then release.
+  if (bit == 0) {
+    microDelay(59);
+    lgGpioWrite(handle, gpio, 1);
+  // If 1, release first, then wait the rest of the 60us slot.
+  } else {
+    lgGpioWrite(handle, gpio, 1);
+    microDelay(59);
+  }
+  // Minimum 1us recovery time after each slot.
+  microDelay(1);
+  return Qnil;
+}
+
+static VALUE one_wire_reset(VALUE self, VALUE rbHandle, VALUE rbGPIO) {
+  int handle = NUM2INT(rbHandle);
+  int gpio   = NUM2INT(rbGPIO);
+  struct timespec start;
+  uint8_t presence = 1;
+
+  // Hold low for 500us to reset, then go high.
+  lgGpioFree(handle, gpio);
+  lgGpioClaimOutput(handle, LG_SET_OPEN_DRAIN | LG_SET_PULL_UP, gpio, 0);
+  microDelay(500);
+  lgGpioWrite(handle, gpio, 1);
+
+  // Poll for 250us. If a device pulls the line low, return 0 (device present).
+  clock_gettime(CLOCK_MONOTONIC, &start);
+  while(nanosSince(&start) < 250000){
+    if (lgGpioRead(handle, gpio) == 0) presence = 0;
+  }
+
+  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                                  */
+/*****************************************************************************/
 void Init_lgpio(void) {
   // Modules
   VALUE mLGPIO = rb_define_module("LGPIO");
@@ -354,6 +778,7 @@ void Init_lgpio(void) {
   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_get_mode",      gpio_get_mode,     2);
   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);
@@ -373,15 +798,20 @@ 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);
 
-  // PWM / Servo / Wave
+  // 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));
   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);
+  // Don't use this. Servo will jitter.
+  rb_define_singleton_method(mLGPIO, "tx_servo", tx_servo, 6);
 
   // I2C
   rb_define_singleton_method(mLGPIO, "i2c_open",           i2c_open,          3);
@@ -397,4 +827,19 @@ void Init_lgpio(void) {
   rb_define_singleton_method(mLGPIO, "spi_write",          spi_write,         2);
   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-banged 1-Wire
+  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/lib/lgpio/hardware_pwm.rb

@@ -23,6 +23,18 @@ module LGPIO
       @path ||= "#{SYS_FS_PWM_PATH}pwmchip#{@chip}/pwm#{@channel}/"
     end
 
+    def period_path
+      @period_path ||= "#{path}period"
+    end
+
+    def duty_path
+      @duty_path ||= "#{path}duty_cycle"
+    end
+
+    def enable_path
+      @enable_path ||= "#{path}enable"
+    end
+
     def frequency=(freq)
       self.period = (NS_PER_S / freq.to_f).round
     end
@@ -30,13 +42,14 @@ module LGPIO
     def period=(p)
       old_period = File.read("#{path}period").strip.to_i
       unless (old_period == 0)
-        File.open("#{path}duty_cycle", 'w') { |f| f.write("0") }
+        File.open(duty_path, 'w') { |f| f.write("0") }
       end
-      File.open("#{path}period", 'w')     { |f| f.write(p)   }
+      File.open(period_path, 'w') { |f| f.write(p) }
       @period = p
     end
 
     def duty_percent
+      return 0.0 if (!duty || !period) || (duty == 0)
       (duty / period.to_f) * 100.0
     end
 
@@ -53,17 +66,17 @@ module LGPIO
 
     def duty=(d_ns)
       raise "duty cycle: #{d_ns} ns cannot be longer than period: #{period} ns" if d_ns > period
-      File.open("#{path}duty_cycle", 'w') { |f| f.write(d_ns) }
+      File.open(duty_path, 'w') { |f| f.write(d_ns) }
       @duty = d_ns
     end
 
     def disable
-      File.open("#{path}enable", 'w') { |f| f.write("0") }
+      File.open(enable_path, 'w') { |f| f.write("0") }
       @enabled = false
     end
 
     def enable
-      File.open("#{path}enable", 'w') { |f| f.write("1") }
+      File.open(enable_path, 'w') { |f| f.write("1") }
       @enabled = true
     end
   end