lgpio 0.1.5 → 0.1.7

data/examples/spi_bb_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/ext/lgpio/lgpio.c

@@ -1,13 +1,50 @@
 #include <lgpio.h>
 #include <ruby.h>
+#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;
+  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);
+}
+
+/*****************************************************************************/
+/*                              CHIP & GPIO                                 */
+/*****************************************************************************/
 static VALUE chip_open(VALUE self, VALUE gpio_dev) {
   int result = lgGpiochipOpen(NUM2INT(gpio_dev));
   return INT2NUM(result);
@@ -18,6 +55,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 +135,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,13 +168,12 @@ static VALUE gpio_get_report(VALUE self){
   }
   pthread_mutex_unlock(&queueLock);
 
-  if (popped){
-    return hash;
-  } else {
-    return Qnil;
-  }
+  return (popped) ? hash : Qnil;
 }
 
+/*****************************************************************************/
+/*                          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);
@@ -176,6 +217,53 @@ 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.
+  //
+  // 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);
+}
+
+/*****************************************************************************/
+/*                             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);
@@ -239,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);
@@ -338,6 +429,178 @@ static VALUE spi_ws2812_write(VALUE self, VALUE handle, VALUE pixelArray){
   return INT2NUM(result);
 }
 
+/*****************************************************************************/
+/*                           BIT-BANG PULSE INPUT                            */
+/*****************************************************************************/
+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;
+}
+
+/*****************************************************************************/
+/*                       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);
+  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);
+}
+
+/*****************************************************************************/
+/*                           EXTENSION INIT                                  */
+/*****************************************************************************/
 void Init_lgpio(void) {
   // Modules
   VALUE mLGPIO = rb_define_module("LGPIO");
@@ -354,6 +617,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 +637,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
+  // 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);
+
+  // 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);
@@ -397,4 +666,13 @@ 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);
+
+  // 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-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);
 }

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

data/lib/lgpio/i2c_bitbang.rb

@@ -0,0 +1,117 @@
+module LGPIO
+  class I2CBitBang
+    VALID_ADDRESSES = (0x08..0x77).to_a
+
+    attr_reader :handle, :scl, :sda
+
+    def initialize(handle, scl, sda)
+      @handle = handle
+      @scl    = scl
+      @sda    = sda
+      @sda_state = nil
+      initialize_pins
+    end
+
+    def initialize_pins
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_PULL_NONE, scl, LGPIO::HIGH)
+      LGPIO.gpio_claim_output(handle, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, sda, LGPIO::HIGH)
+    end
+
+    def set_sda(value)
+      return if (@sda_state == value)
+      LGPIO.gpio_write(handle, sda, @sda_state = value)
+    end
+
+    def write_form(address)
+      (address << 1)
+    end
+
+    def read_form(address)
+      (address << 1) | 0b00000001
+    end
+
+    def start
+      LGPIO.gpio_write(handle, sda, 0)
+      LGPIO.gpio_write(handle, scl, 0)
+    end
+
+    def stop
+      LGPIO.gpio_write(handle, sda, 0)
+      LGPIO.gpio_write(handle, scl, 1)
+      LGPIO.gpio_write(handle, sda, 1)
+    end
+
+    def read_bit
+      set_sda(1)
+      LGPIO.gpio_write(handle, scl, 1)
+      bit = LGPIO.gpio_read(handle, sda)
+      LGPIO.gpio_write(handle, scl, 0)
+      bit
+    end
+
+    def write_bit(bit)
+      set_sda(bit)
+      LGPIO.gpio_write(handle, scl, 1)
+      LGPIO.gpio_write(handle, scl, 0)
+    end
+
+    def read_byte(ack)
+      byte = 0
+      i    = 0
+      while i < 8
+        byte = (byte << 1) | read_bit
+        i = i + 1
+      end
+      write_bit(ack ? 0 : 1)
+      byte
+    end
+
+    def write_byte(byte)
+      i = 7
+      while i >= 0
+        write_bit (byte >> i) & 0b1
+        i = i - 1
+      end
+      # Return ACK (SDA pulled low) or NACK (SDA stayed high).
+      (read_bit == 0)
+    end
+
+    def read(address, length)
+      raise ArgumentError, "invalid I2C address: #{address}. Range is 0x08..0x77" unless VALID_ADDRESSES.include?(address)
+      raise ArgumentError, "invalid Integer for read length: #{length}" unless length.kind_of?(Integer)
+
+      start
+      ack = write_byte(read_form(address))
+      return nil unless ack
+
+      # Read length bytes, and ACK for all but the last one.
+      bytes = []
+      (length-1).times { bytes << read_byte(true) }
+      bytes << read_byte(false)
+      stop
+
+      bytes
+    end
+
+    def write(address, bytes)
+      raise ArgumentError, "invalid I2C address: #{address}. Range is 0x08..0x77" unless VALID_ADDRESSES.include?(address)
+      raise ArgumentError, "invalid byte Array to write: #{bytes}" unless bytes.kind_of?(Array)
+
+      start
+      write_byte(write_form(address))
+      bytes.each { |byte| write_byte(byte) }
+      stop
+    end
+
+    def search
+      found = []
+      VALID_ADDRESSES.each do |address|
+        start
+        # Device present if ACK received when we write its address to the bus.
+        found << address if write_byte(write_form(address))
+        stop
+      end
+      found
+    end
+  end
+end

data/lib/lgpio/infrared.rb

@@ -0,0 +1,8 @@
+module LGPIO
+  class Infrared < HardwarePWM
+    def transmit(pulses, duty: 33.333)
+      self.duty_percent = duty
+      tx_wave_ook(duty_path, @duty.to_s, pulses)
+    end
+  end
+end