lgpio 0.1.9 → 0.1.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 968e706762503c9d172b41ff4df8a9c17021af5b4a4cb4372eeaaa166c30f5ff
-  data.tar.gz: 82d8221f8e28293f542c4bd1913f85addb567c217d071fdbb1e47451c3be1da1
+  metadata.gz: 3371c46b2f589524fba421f579bd0f779d5e006eb62ef6d7480e8ca39cdf7540
+  data.tar.gz: 704f472a31ca5d9711a300ce5ce05ce89f930dd2322192a7251ce8cdab8f5abe
 SHA512:
-  metadata.gz: 8749280110629032e20ac94c203c512a699e90b58266f78f7c26a9305b8e22ef0f97822247744403c2723b7417838b5972c2618a65ebcb0ee2ae483cd0d12e41
-  data.tar.gz: a9bbac8e2f8c80de6adf86249bf559b10c590234597a15d3bf6dce37bc3b60ce27856f2343bdc1fe885a1a78105401419e221eb0ae5a10fa404ec7fc9c90a4fd
+  metadata.gz: cf2c6d2fec7b57b371a69c11ba1e7fd66997c72581a19c09bc73dc224e59be6e7347450d2499d84af38b4b73465e97bcf6d3021975b9427fd7f52a729cad2b08
+  data.tar.gz: 8fe39d478e3453cf5d42452a59552660742b249b9f533fbec506dfde165c746fe2ab3dada38fbde8ea60e8567e57419a6393faa9236b97772954a9d96f619829

data/README.md

@@ -38,7 +38,7 @@ These use the sysfs PWM interface, not lgpio C, but are a good fit for this gem.
   - Carrier generated by hardware PWM. Software modulated with monotonic clock timing.
   - Useful for sending infrared signals at 38kHz, for example.
 
-**Note:** Once hardware PWM is used on a pin, it stays PWM until reboot. The associated GPIO won't work.
+**Note:** Once a pin is bound to hardware PWM in the device tree, it shouldn't be used as regular GPIO. Behavior is inconsistent across different hardware.
 
 ## Installation
 On Debian-based Linuxes (RaspberryPi OS, Armbian, DietPi etc.):

data/examples/i2c_bb_aht10.rb

@@ -9,13 +9,19 @@ SOFT_RESET          = [0xBA]
 INIT_AND_CALIBRATE  = [0xE1, 0x08, 0x00]
 START_MEASUREMENT   = [0xAC, 0x33, 0x00]
 
-GPIO_CHIP = 0
+SCL_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 ADDRESS   = 0x38
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
 
 # Startup sequence
 sleep(POWER_ON_DELAY)
@@ -24,11 +30,15 @@ sleep(RESET_DELAY)
 i2c_bb.write(ADDRESS, INIT_AND_CALIBRATE)
 sleep(COMMAND_DELAY)
 
-# Read and close
+# Read
 i2c_bb.write(ADDRESS, START_MEASUREMENT)
 sleep(MEASURE_DELAY)
 bytes = i2c_bb.read(ADDRESS, DATA_LENGTH)
 
+# Close
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_handle)
+
 # 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

data/examples/i2c_bb_search.rb

@@ -1,13 +1,23 @@
 require 'lgpio'
 
-GPIO_CHIP = 0
+SCL_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
+
 devices = i2c_bb.search
 
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_handle)
+
 if devices.empty?
   puts "No devices found on I2C bus"
 else

data/examples/i2c_bb_ssd1306_bench.rb

@@ -5,13 +5,19 @@ 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_CHIP  = 0
 SCL_PIN   = 228
+SDA_CHIP  = 0
 SDA_PIN   = 270
 ADDRESS   = 0x3C
 
-chip_handle = LGPIO.chip_open(GPIO_CHIP)
-i2c_bb = LGPIO::I2CBitBang.new(chip_handle, SCL_PIN, SDA_PIN)
+scl_handle = LGPIO.chip_open(SCL_CHIP)
+sda_handle = (SCL_CHIP == SDA_CHIP) ? scl_handle : LGPIO.chip_open(SDA_CHIP)
+pin_hash =  {
+              scl: { handle: scl_handle, line: SCL_PIN },
+              sda: { handle: sda_handle, line: SDA_PIN },
+            }
+i2c_bb = LGPIO::I2CBitBang.new(pin_hash)
 
 i2c_bb.write(ADDRESS, INIT_ARRAY)
 FRAME_COUNT = 400
@@ -25,11 +31,12 @@ start = Time.now
 end
 finish = Time.now
 
-LGPIO.chip_close(chip_handle)
+LGPIO.chip_close(scl_handle)
+LGPIO.chip_close(sda_handle) unless (scl_handle == sda_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
+# Also calculate C calls per second, using roughly 24.5 GPIO calls per byte written.
+cps = (START_ARRAY.length + ((PATTERN_1.length + PATTERN_2.length) / 2) + 2) * 24.5 * fps
 cps = (cps / 1000.0).round
 
 puts "SSD1306 benchmark result: #{fps.round(2)} fps | #{cps}k C calls/s"

data/examples/spi_bb_loopback.rb

@@ -10,7 +10,12 @@ ORDERS      = [:msbfirst, :lsbfirst]
 TX_BYTES    = [0, 1, 2, 3, 4, 5, 6, 7]
 
 chip_handle = LGPIO.chip_open(GPIO_CHIP)
-spi_bb      = LGPIO::SPIBitBang.new(handle: chip_handle, clock: CLOCK_PIN, input: INPUT_PIN, output: OUTPUT_PIN)
+pin_hash    = {
+                clock:  { handle: chip_handle, line: CLOCK_PIN  },
+                input:  { handle: chip_handle, line: INPUT_PIN  },
+                output: { handle: chip_handle, line: OUTPUT_PIN },
+              }
+spi_bb      = LGPIO::SPIBitBang.new(pin_hash)
 
 puts "TX bytes => #{TX_BYTES.inspect}"
 

data/examples/spi_bb_sim_bench.rb

@@ -12,7 +12,12 @@ 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)
+pin_hash    = {
+                clock:  { handle: chip_handle, line: CLOCK_PIN  },
+                input:  { handle: chip_handle, line: INPUT_PIN  },
+                output: { handle: chip_handle, line: OUTPUT_PIN },
+              }
+spi_bb      = LGPIO::SPIBitBang.new(pin_hash)
 
 start = Time.now
 (FRAME_COUNT / 2).times do

data/examples/spi_bb_ssd1306_bench.rb

@@ -5,41 +5,53 @@ 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, SELECT_PIN, LGPIO::SET_PULL_NONE, LGPIO::HIGH)
-LGPIO.gpio_claim_output(chip_handle, RESET_PIN, LGPIO::SET_PULL_NONE, LGPIO::LOW)
-LGPIO.gpio_claim_output(chip_handle, DC_PIN, LGPIO::SET_PULL_NONE, LGPIO::LOW)
+# Pins for Radxa Zero 3W
+# Demonstration of how to use GPIOs across multiple /dev/gpiochip devices.
+pins = {
+  clock:  { chip: 1, line: 4 },
+  output: { chip: 3, line: 4 },
+  reset:  { chip: 3, line: 5 },
+  dc:     { chip: 3, line: 6 },
+  cs:     { chip: 3, line: 7 },
+}
+
+# Open chip handles without duplicating.
+open_handles = []
+pins.each_value do |hash|
+  if hash[:handle] = open_handles[hash[:chip]]
+  else
+    hash[:handle] = LGPIO.chip_open(hash[:chip])
+    open_handles[hash[:chip]] = hash[:handle]
+  end
+end
+
+spi_bb = LGPIO::SPIBitBang.new(clock: pins[:clock], output: pins[:output])
+LGPIO.gpio_claim_output(pins[:reset][:handle], pins[:reset][:line], LGPIO::SET_PULL_NONE, LGPIO::LOW)
+LGPIO.gpio_claim_output(pins[:dc][:handle], pins[:dc][:line], LGPIO::SET_PULL_NONE, LGPIO::LOW)
+LGPIO.gpio_claim_output(pins[:cs][:handle], pins[:cs][:line], LGPIO::SET_PULL_NONE, LGPIO::HIGH)
 
 # 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)
+LGPIO.gpio_write(pins[:reset][:handle], pins[:reset][:line], 1)
+LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+spi_bb.transfer(write: INIT_ARRAY, select: pins[:cs])
 
 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)
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+  spi_bb.transfer(write: START_ARRAY, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 1)
+  spi_bb.transfer(write: PATTERN_1, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 0)
+  spi_bb.transfer(write: START_ARRAY, select: pins[:cs])
+  LGPIO.gpio_write(pins[:dc][:handle], pins[:dc][:line], 1)
+  spi_bb.transfer(write: PATTERN_2, select: pins[:cs])
 end
 finish = Time.now
 
-LGPIO.chip_close(chip_handle)
+# Close all handles.
+open_handles.compact.each { |h| LGPIO.chip_close(h) }
 
 fps = FRAME_COUNT / (finish - start)
 # Also calculate C calls per second, using roughly 20 calls per byte written.

data/examples/spi_hw_loopback.rb

@@ -12,7 +12,7 @@ puts "TX bytes: #{tx_bytes.inspect}"
 
 # rx_bytes == tx_bytes if MOSI looped back to MISO.
 # rx_byte all 255 when MOSI and MISO not connected.
-rx_bytes = LGPIO.spi_xfer(spi_handle, tx_bytes)
+rx_bytes = LGPIO.spi_xfer(spi_handle, tx_bytes, tx_bytes.length)
 puts "RX bytes: #{rx_bytes.inspect}"
 
 LGPIO.spi_close(spi_handle)

data/ext/lgpio/lgpio.c

@@ -42,6 +42,11 @@ static void microDelay(uint64_t micros) {
   nanoDelay(micros * 1000);
 }
 
+static VALUE rbMicroDelay(VALUE self, VALUE micros) {
+  microDelay(NUM2ULL(micros));
+  return Qnil;
+}
+
 /*****************************************************************************/
 /*                              CHIP & GPIO                                 */
 /*****************************************************************************/
@@ -86,6 +91,7 @@ static VALUE gpio_write(VALUE self, VALUE handle, VALUE gpio, VALUE level) {
 }
 
 static VALUE group_claim_input(VALUE self, VALUE handle, VALUE gpios, VALUE flags) {
+  Check_Type(gpios, T_ARRAY);
   int count = rb_array_len(gpios);
   int lgGpios[count];
   int i;
@@ -97,6 +103,7 @@ static VALUE group_claim_input(VALUE self, VALUE handle, VALUE gpios, VALUE flag
 }
 
 static VALUE group_claim_output(VALUE self, VALUE handle, VALUE gpios, VALUE flags, VALUE levels) {
+  Check_Type(gpios, T_ARRAY);
   int count = rb_array_len(gpios);
   int lgGpios[count];
   int lgLevels[count];
@@ -190,7 +197,7 @@ static VALUE tx_pulse(VALUE self, VALUE handle, VALUE gpio, VALUE on, VALUE off,
 }
 
 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));
+  int result = lgTxPwm(NUM2INT(handle), NUM2INT(gpio), NUM2INT(freq), NUM2DBL(duty), NUM2INT(offset), NUM2INT(cycles));
   return INT2NUM(result);
 }
 
@@ -201,6 +208,7 @@ static VALUE tx_servo(VALUE self, VALUE handle, VALUE gpio, VALUE width, VALUE f
 
 static VALUE tx_wave(VALUE self, VALUE handle, VALUE lead_gpio, VALUE pulses) {
   // Copy Ruby array to array of lgPulse_t.
+  Check_Type(pulses, T_ARRAY);
   int       pulseCount = rb_array_len(pulses);
   lgPulse_t pulsesOut[pulseCount];
   VALUE     rbPulse;
@@ -225,9 +233,10 @@ static VALUE tx_wave_ook(VALUE self, VALUE dutyPath, VALUE dutyString, VALUE pul
   // The Ruby class LGPIO::HardwarePWM should have already set the PWM carrier frequency.
   //
   // Convert pulses from microseconds to nanoseconds.
+  Check_Type(pulses, T_ARRAY);
   uint32_t pulseCount = rb_array_len(pulses);
   uint64_t nanoPulses[pulseCount];
-  for (int i=0; i<pulseCount; i++) {
+  for (uint32_t i=0; i<pulseCount; i++) {
     nanoPulses[i] = NUM2UINT(rb_ary_entry(pulses, i)) * 1000;
   }
 
@@ -242,7 +251,7 @@ static VALUE tx_wave_ook(VALUE self, VALUE dutyPath, VALUE dutyString, VALUE pul
   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++) {
+  for (uint32_t i=0; i<pulseCount; i++) {
     if (i % 2 == 0) {
       dutyFile = fopen(filePath, "w");
       fputs(cDuty, dutyFile);
@@ -259,6 +268,7 @@ static VALUE tx_wave_ook(VALUE self, VALUE dutyPath, VALUE dutyString, VALUE pul
   dutyFile = fopen(filePath, "w");
   fputs("0", dutyFile);
   fclose(dutyFile);
+  return UINT2NUM(pulseCount);
 }
 
 /*****************************************************************************/
@@ -274,12 +284,13 @@ static VALUE i2c_close(VALUE self, VALUE handle){
   return INT2NUM(result);
 }
 
-static VALUE i2c_write_device(VALUE self, VALUE handle, VALUE byteArray){
-  int count = RARRAY_LEN(byteArray);
+static VALUE i2c_write_device(VALUE self, VALUE handle, VALUE txArray){
+  Check_Type(txArray, T_ARRAY);
+  int count = rb_array_len(txArray);
   uint8_t txBuf[count];
   VALUE currentByte;
   for(int i=0; i<count; i++){
-    currentByte = rb_ary_entry(byteArray, i);
+    currentByte = rb_ary_entry(txArray, i);
     Check_Type(currentByte, T_FIXNUM);
     txBuf[i] = NUM2CHR(currentByte);
   }
@@ -303,7 +314,8 @@ static VALUE i2c_read_device(VALUE self, VALUE handle, VALUE count){
 }
 
 static VALUE i2c_zip(VALUE self, VALUE handle, VALUE txArray, VALUE rb_rxCount){
-  int txCount = RARRAY_LEN(txArray);
+  Check_Type(txArray, T_ARRAY);
+  int txCount = rb_array_len(txArray);
   uint8_t txBuf[txCount];
   VALUE currentByte;
   for(int i=0; i<txCount; i++){
@@ -357,7 +369,8 @@ static VALUE spi_read(VALUE self, VALUE handle, VALUE rxCount){
 }
 
 static VALUE spi_write(VALUE self, VALUE handle, VALUE txArray){
-  int count = RARRAY_LEN(txArray);
+  Check_Type(txArray, T_ARRAY);
+  int count = rb_array_len(txArray);
   uint8_t txBuf[count];
   VALUE currentByte;
   for(int i=0; i<count; i++){
@@ -370,31 +383,42 @@ static VALUE spi_write(VALUE self, VALUE handle, VALUE txArray){
   return INT2NUM(result);
 }
 
-static VALUE spi_xfer(VALUE self, VALUE handle, VALUE txArray){
-  int count = RARRAY_LEN(txArray);
+static VALUE spi_xfer(VALUE self, VALUE handle, VALUE txArray, VALUE rxLength){
+  Check_Type(txArray, T_ARRAY);
+  int txCount = rb_array_len(txArray);
+  int rxCount = NUM2INT(rxLength);
+  int count   = txCount;
+  if (rxCount > txCount) count = rxCount;
+
   uint8_t txBuf[count];
+  // Not sure if this needs null termination like I2C. +1 won't hurt.
+  uint8_t rxBuf[count+1];
+
+  // Add given bytes to transmit.
   VALUE currentByte;
-  for(int i=0; i<count; i++){
+  for(int i=0; i<txCount; i++){
     currentByte = rb_ary_entry(txArray, i);
     Check_Type(currentByte, T_FIXNUM);
     txBuf[i] = NUM2CHR(currentByte);
   }
-
-  // Not sure if this needs null termination like I2C. +1 won't hurt.
-  uint8_t rxBuf[count+1];
+  // Extend with zeroes if reading more than writing.
+  if (count > txCount) {
+    for(int i=txCount; i<count; i++) txBuf[i] = 0;
+  }
 
   int result = lgSpiXfer(NUM2INT(handle), txBuf, rxBuf, count);
   if(result < 0) return INT2NUM(result);
 
-  VALUE retArray = rb_ary_new2(count);
-  for(int i=0; i<count; i++){
+  VALUE retArray = rb_ary_new2(rxCount);
+  for(int i=0; i<rxCount; i++){
     rb_ary_store(retArray, i, UINT2NUM(rxBuf[i]));
   }
   return retArray;
 }
 
 static VALUE spi_ws2812_write(VALUE self, VALUE handle, VALUE pixelArray){
-  int count = RARRAY_LEN(pixelArray);
+  Check_Type(pixelArray, T_ARRAY);
+  int count = rb_array_len(pixelArray);
 
   // Pull low for at least one byte at 2.4 Mhz before data, and 90 after.
   int zeroesBefore = 1;
@@ -522,7 +546,7 @@ static VALUE gpio_read_pulses_us(VALUE self, VALUE rbHandle, VALUE rbGPIO, VALUE
   // 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++){
+  for(uint32_t i=0; i<pulseIndex; i++){
     uint32_t pulse_us = round(pulses_ns[i] / 1000.0);
     rb_ary_store(retArray, i, UINT2NUM(pulse_us));
   }
@@ -598,6 +622,83 @@ static VALUE one_wire_reset(VALUE self, VALUE rbHandle, VALUE rbGPIO) {
   return UINT2NUM(presence);
 }
 
+/*****************************************************************************/
+/*                          Bit-Bang I2C Helpers                             */
+/*****************************************************************************/
+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 void i2c_bb_set_sda(int handle, int gpio, uint8_t* state, uint8_t level) {
+  if (level == *state) return;
+  lgGpioWrite(handle, gpio, level);
+  *state = level;
+}
+
+static VALUE i2c_bb_read_byte(VALUE self, VALUE rbSCL_H, VALUE rbSCL_L, VALUE rbSDA_H, VALUE rbSDA_L, VALUE rbACK) {
+  int scl_H   = NUM2INT(rbSCL_H);
+  int scl_L   = NUM2INT(rbSCL_L);
+  int sda_H   = NUM2INT(rbSDA_H);
+  int sda_L   = NUM2INT(rbSDA_L);
+  uint8_t ack = RTEST(rbACK);
+
+  // Prevent caching by setting opposite to first state SDA will take.
+  uint8_t sdaState = 0;
+  uint8_t b;
+  uint8_t bit;
+
+  // Receive MSB first.
+  for (int i=7; i>=0; i--) {
+    i2c_bb_set_sda(sda_H, sda_L, &sdaState, 1);
+    lgGpioWrite(scl_H, scl_L, 1);
+    bit = lgGpioRead(sda_H, sda_L);
+    lgGpioWrite(scl_H, scl_L, 0);
+
+    bitWriteU8(&b, i, bit);
+  }
+
+  // Send ACK or NACK.
+  i2c_bb_set_sda(sda_H, sda_L, &sdaState, ack ^ 0b1);
+  lgGpioWrite(scl_H, scl_L, 1);
+  lgGpioWrite(scl_H, scl_L, 0);
+
+  return UINT2NUM(b);
+}
+
+static VALUE i2c_bb_write_byte(VALUE self, VALUE rbSCL_H, VALUE rbSCL_L, VALUE rbSDA_H, VALUE rbSDA_L, VALUE rbByte) {
+  int scl_H   = NUM2INT(rbSCL_H);
+  int scl_L   = NUM2INT(rbSCL_L);
+  int sda_H   = NUM2INT(rbSDA_H);
+  int sda_L   = NUM2INT(rbSDA_L);
+  uint8_t b   = NUM2UINT(rbByte);
+
+  // Prevent caching by setting opposite to first state SDA will take.
+  uint8_t sdaState = bitReadU8(&b, 7) ^ 0b1;
+  uint8_t ack;
+
+  // Write MSBFIRST.
+  for (int i=7; i>=0; i--) {
+    i2c_bb_set_sda(sda_H, sda_L, &sdaState, bitReadU8(&b, i));
+    lgGpioWrite(scl_H, scl_L, 1);
+    lgGpioWrite(scl_H, scl_L, 0);
+  }
+
+  // Read and return ACK.
+  i2c_bb_set_sda(sda_H, sda_L, &sdaState, 1);
+  lgGpioWrite(scl_H, scl_L, 1);
+  ack = lgGpioRead(sda_H, sda_L);
+  lgGpioWrite(scl_H, scl_L, 0);
+  return (ack == 0) ? Qtrue : Qfalse;
+}
+
 /*****************************************************************************/
 /*                           EXTENSION INIT                                  */
 /*****************************************************************************/
@@ -605,7 +706,7 @@ void Init_lgpio(void) {
   // Modules
   VALUE mLGPIO = rb_define_module("LGPIO");
 
-  // Basics
+  // Constants
   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));
@@ -615,6 +716,11 @@ void Init_lgpio(void) {
   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));
+
+  // Generic Helpers
+  rb_define_singleton_method(mLGPIO, "micro_delay",        rbMicroDelay,      1);
+
+  // Basic GPIO
   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);
@@ -648,23 +754,23 @@ 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.
+  // HW PWM waves, on-off-keying only.
   VALUE cHardwarePWM = rb_define_class_under(mLGPIO, "HardwarePWM", rb_cObject);
   rb_define_method(cHardwarePWM, "tx_wave_ook", tx_wave_ook, 3);
 
-  // I2C
+  // HW I2C
   rb_define_singleton_method(mLGPIO, "i2c_open",           i2c_open,          3);
   rb_define_singleton_method(mLGPIO, "i2c_close",          i2c_close,         1);
   rb_define_singleton_method(mLGPIO, "i2c_write_device",   i2c_write_device,  2);
   rb_define_singleton_method(mLGPIO, "i2c_read_device",    i2c_read_device,   2);
   rb_define_singleton_method(mLGPIO, "i2c_zip",            i2c_zip,           3);
 
-  // SPI
+  // HW SPI
   rb_define_singleton_method(mLGPIO, "spi_open",           spi_open,          4);
   rb_define_singleton_method(mLGPIO, "spi_close",          spi_close,         1);
   rb_define_singleton_method(mLGPIO, "spi_read",           spi_read,          2);
   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_xfer",           spi_xfer,          3);
   rb_define_singleton_method(mLGPIO, "spi_ws2812_write",   spi_ws2812_write,  2);
 
   // Bit-Bang Pulse Input
@@ -675,4 +781,8 @@ void Init_lgpio(void) {
   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-bang I2C Helpers
+  rb_define_singleton_method(mLGPIO, "i2c_bb_write_byte",   i2c_bb_write_byte,  5);
+  rb_define_singleton_method(mLGPIO, "i2c_bb_read_byte",    i2c_bb_read_byte,   5);
 }

data/lgpio.gemspec

@@ -4,7 +4,7 @@ Gem::Specification.new do |s|
   s.name        = 'lgpio'
   s.version     = LGPIO::VERSION
   s.licenses    = ['MIT']
-  s.summary     = "Use Linux GPIO, I2C, SPI and PWM in Ruby"
+  s.summary     = "Ruby C extension for Linux GPIO"
   s.description = "Use Linux GPIO, I2C, SPI and PWM in Ruby"
 
   s.authors     = ["vickash"]
@@ -13,5 +13,6 @@ Gem::Specification.new do |s|
   s.homepage    = 'https://github.com/denko-rb/lgpio'
   s.metadata    = { "source_code_uri" => "https://github.com/denko-rb/lgpio" }
 
+  s.required_ruby_version = '>=3'
   s.extensions = %w[ext/lgpio/extconf.rb]
 end

data/lib/lgpio/hardware_pwm.rb

@@ -4,7 +4,7 @@ module LGPIO
     NS_PER_US = 1_000
     SYS_FS_PWM_PATH = "/sys/class/pwm/"
 
-    attr_reader :period, :duty, :enabled
+    attr_reader :polarity, :period, :duty, :enabled
 
     def initialize(chip, channel, frequency: nil, period: nil)
       @chip    = chip
@@ -16,6 +16,11 @@ module LGPIO
       end
 
       period ? self.period = period : self.frequency = frequency
+
+      # Default to with 0 duty cycle and normal polarity.
+      self.duty = 0
+      self.polarity = :normal
+
       enable
     end
 
@@ -23,6 +28,10 @@ module LGPIO
       @path ||= "#{SYS_FS_PWM_PATH}pwmchip#{@chip}/pwm#{@channel}/"
     end
 
+    def polarity_path
+      @polarity_path ||= "#{path}polarity"
+    end
+
     def period_path
       @period_path ||= "#{path}period"
     end
@@ -35,8 +44,24 @@ module LGPIO
       @enable_path ||= "#{path}enable"
     end
 
+    def polarity=(p=:normal)
+      if p == :inversed
+        File.open(polarity_path, 'w') { |f| f.write("inversed") }
+        @polarity = :inversed
+      else
+        File.open(polarity_path, 'w') { |f| f.write("normal") }
+        @polarity = :normal
+      end
+    end
+
     def frequency=(freq)
       self.period = (NS_PER_S / freq.to_f).round
+      @frequency = freq
+    end
+
+    def frequency
+      # If not set explicitly, calculate from period, rounded to nearest Hz.
+      @frequency ||= (1_000_000_000.0 / period).round
     end
 
     def period=(p)
@@ -45,6 +70,7 @@ module LGPIO
         File.open(duty_path, 'w') { |f| f.write("0") }
       end
       File.open(period_path, 'w') { |f| f.write(p) }
+      @frequency = nil
       @period = p
     end
 

data/lib/lgpio/i2c_bitbang.rb

@@ -2,24 +2,36 @@ module LGPIO
   class I2CBitBang
     VALID_ADDRESSES = (0x08..0x77).to_a
 
-    attr_reader :handle, :scl, :sda
+    attr_reader :scl_handle, :scl_line, :sda_handle, :sda_line
 
-    def initialize(handle, scl, sda)
-      @handle = handle
-      @scl    = scl
-      @sda    = sda
-      @sda_state = nil
+    def initialize(options={})
+      scl  = options[:scl]
+      sda  = options[:sda]
+
+      @scl_handle = scl[:handle] if scl
+      @scl_line   = scl[:line]   if scl
+      raise ArgumentError, ":scl pin required as Hash, with :handle and :line required" unless (@scl_handle && @scl_line)
+
+      @sda_handle = sda[:handle] if sda
+      @sda_line   = sda[:line]   if sda
+      raise ArgumentError, ":sda pin required as Hash, with :handle and :line required" unless (@sda_handle && @sda_line)
+
+      @sda_state  = nil
       initialize_pins
     end
 
+    def config
+      @config ||= [scl_handle, scl_line, sda_handle, scl_line]
+    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)
+      LGPIO.gpio_claim_output(scl_handle, scl_line, LGPIO::SET_PULL_NONE, LGPIO::HIGH)
+      LGPIO.gpio_claim_output(sda_handle, sda_line, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, LGPIO::HIGH)
     end
 
     def set_sda(value)
       return if (@sda_state == value)
-      LGPIO.gpio_write(handle, sda, @sda_state = value)
+      LGPIO.gpio_write(sda_handle, sda_line, @sda_state = value)
     end
 
     def write_form(address)
@@ -31,28 +43,28 @@ module LGPIO
     end
 
     def start
-      LGPIO.gpio_write(handle, sda, 0)
-      LGPIO.gpio_write(handle, scl, 0)
+      LGPIO.gpio_write(sda_handle, sda_line, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
     end
 
     def stop
-      LGPIO.gpio_write(handle, sda, 0)
-      LGPIO.gpio_write(handle, scl, 1)
-      LGPIO.gpio_write(handle, sda, 1)
+      LGPIO.gpio_write(sda_handle, sda_line, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      LGPIO.gpio_write(sda_handle, sda_line, 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)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      bit = LGPIO.gpio_read(sda_handle, sda_line)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
       bit
     end
 
     def write_bit(bit)
       set_sda(bit)
-      LGPIO.gpio_write(handle, scl, 1)
-      LGPIO.gpio_write(handle, scl, 0)
+      LGPIO.gpio_write(scl_handle, scl_line, 1)
+      LGPIO.gpio_write(scl_handle, scl_line, 0)
     end
 
     def read_byte(ack)
@@ -76,6 +88,14 @@ module LGPIO
       (read_bit == 0)
     end
 
+    def read_byte_c(ack)
+      LGPIO.i2c_bb_read_byte(@scl_handle, @scl_line, @sda_handle, @sda_line, ack)
+    end
+
+    def write_byte_c(byte)
+      LGPIO.i2c_bb_write_byte(@scl_handle, @scl_line, @sda_handle, @sda_line, byte)
+    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)
@@ -86,10 +106,16 @@ module LGPIO
 
       # Read length bytes, and ACK for all but the last one.
       bytes = []
-      (length-1).times { bytes << read_byte(true) }
-      bytes << read_byte(false)
-      stop
 
+      # Bit-bang per-byte in Ruby.
+      # (length-1).times { bytes << read_byte(true) }
+      # bytes << read_byte(false)
+
+      # Bit-bang per-byte in C.
+      (length-1).times { bytes << read_byte_c(true) }
+      bytes << read_byte_c(false)
+
+      stop
       bytes
     end
 
@@ -99,7 +125,13 @@ module LGPIO
 
       start
       write_byte(write_form(address))
-      bytes.each { |byte| write_byte(byte) }
+
+      # Bit-bang per-byte in Ruby.
+      # bytes.each { |byte| write_byte(byte) }
+
+      # Bit-bang per-byte in C.
+      bytes.each { |byte| write_byte_c(byte) }
+
       stop
     end
 

data/lib/lgpio/one_wire.rb

@@ -19,7 +19,7 @@ module LGPIO
       @handle = handle
       @gpio   = gpio
       @found_addresses = []
-      LGPIO.gpio_claim_output(handle, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, gpio, LGPIO::HIGH)
+      LGPIO.gpio_claim_output(handle, gpio, LGPIO::SET_OPEN_DRAIN | LGPIO::SET_PULL_UP, LGPIO::HIGH)
     end
 
     def reset

data/lib/lgpio/spi_bitbang.rb

@@ -1,58 +1,66 @@
 module LGPIO
   class SPIBitBang
-    attr_reader :handle, :clock, :input, :output
+    attr_reader :clock_handle, :input_handle, :output_handle
+    attr_reader :clock_line, :input_line, :output_line
 
     def initialize(options={})
-      @handle = options[:handle]
-      @clock  = options[:clock]  || options[:sck]  || options[:clk]
-      @input  = options[:input]  || options[:poci] || options[:miso]
-      @output = options[:output] || options[:pico] || options[:mosi]
+      clock  = options[:clock]
+      input  = options[:input]
+      output = options[:output]
 
-      raise ArgumentError, "a gpiochip :handle is required" unless @handle
-      raise ArgumentError, "either input/:poci/:miso OR :output/:pico/:mosi pin required" unless (@input || @output)
-      raise ArgumentError, ":clock/:sck/:clk pin required" unless @clock
+      @clock_handle   = clock[:handle] if clock
+      @clock_line     = clock[:line]   if clock
+      raise ArgumentError, ":clock pin required as Hash, with :handle and :line required" unless (@clock_handle && @clock_line)
+
+      @input_handle   = input[:handle]  if input
+      @input_line     = input[:line]    if input
+      @output_handle  = output[:handle] if output
+      @output_line    = output[:line]   if output
+      unless ((@input_handle && @input_line) || (@output_handle && @output_line))
+        raise ArgumentError, "either :input or :output pin required as Hash, with :handle and :line required"
+      end
 
       @output_state = nil
       initialize_pins
     end
 
     def config
-      @config ||= { handle: handle, clock: clock, input: input, output: output }
+      @config ||= [clock_handle, clock_line, input_handle, input_line, output_handle, output_line]
     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
-      LGPIO.gpio_claim_output(handle, LGPIO::SET_PULL_NONE, output, LGPIO::LOW) if output
+      LGPIO.gpio_claim_output(clock_handle,  clock_line,  LGPIO::SET_PULL_NONE, LGPIO::LOW)
+      LGPIO.gpio_claim_input(input_handle,   input_line,  LGPIO::SET_PULL_NONE)             if input_line
+      LGPIO.gpio_claim_output(output_handle, output_line, LGPIO::SET_PULL_NONE, LGPIO::LOW) if output_line
     end
 
     def set_output(level)
       return if (level == @output_state)
-      LGPIO.gpio_write(handle, output, @output_state = level)
+      LGPIO.gpio_write(output_handle, output_line, @output_state = level)
     end
 
     def transfer_bit(write_bit, reading: false, mode: 0)
       case mode
       when 0
         set_output(write_bit) if write_bit
-        LGPIO.gpio_write(handle, clock, 1)
-        read_bit = LGPIO.gpio_read(handle, input) if reading
-        LGPIO.gpio_write(handle, clock, 0)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
       when 1
-        LGPIO.gpio_write(handle, clock, 1)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
         set_output(write_bit) if write_bit
-        LGPIO.gpio_write(handle, clock, 0)
-        read_bit = LGPIO.gpio_read(handle, input) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
       when 2
         set_output(write_bit) if write_bit
-        LGPIO.gpio_write(handle, clock, 0)
-        read_bit = LGPIO.gpio_read(handle, input) if reading
-        LGPIO.gpio_write(handle, clock, 1)
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
       when 3
-        LGPIO.gpio_write(handle, clock, 0)
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
         set_output(write_bit) if write_bit
-        LGPIO.gpio_write(handle, clock, 1)
-        read_bit = LGPIO.gpio_read(handle, input) if reading
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
+        read_bit = LGPIO.gpio_read(input_handle, input_line) if reading
       else
         raise ArgumentError, "invalid SPI mode: #{mode} given"
       end
@@ -87,9 +95,9 @@ module LGPIO
       # Idle clock state depends on SPI mode.
       case mode
       when 0..1
-        LGPIO.gpio_write(handle, clock, 0)
+        LGPIO.gpio_write(clock_handle, clock_line, 0)
       when 2..3
-        LGPIO.gpio_write(handle, clock, 1)
+        LGPIO.gpio_write(clock_handle, clock_line, 1)
       else
         raise ArgumentError, "invalid SPI mode: #{mode} given"
       end
@@ -97,7 +105,7 @@ module LGPIO
       raise ArgumentError, "invalid Integer for read: #{read}" unless read.kind_of?(Integer)
 
       read_bytes = (read > 0) ? [] : nil
-      LGPIO.gpio_write(handle, select, 0) if select
+      LGPIO.gpio_write(select[:handle], select[:line], 0) if select
 
       i = 0
       while (i < read) || (i < write.length)
@@ -106,7 +114,7 @@ module LGPIO
         i = i + 1
       end
 
-      LGPIO.gpio_write(handle, select, 1) if select
+      LGPIO.gpio_write(select[:handle], select[:line], 1) if select
       read_bytes
     end
   end

data/lib/lgpio/version.rb

@@ -1,3 +1,3 @@
 module LGPIO
-  VERSION = "0.1.9"
+  VERSION = "0.1.11"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lgpio
 version: !ruby/object:Gem::Version
-  version: 0.1.9
+  version: 0.1.11
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-09-28 00:00:00.000000000 Z
+date: 2024-10-12 00:00:00.000000000 Z
 dependencies: []
 description: Use Linux GPIO, I2C, SPI and PWM in Ruby
 email: mail@vickash.com
@@ -75,7 +75,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -85,5 +85,5 @@ requirements: []
 rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
-summary: Use Linux GPIO, I2C, SPI and PWM in Ruby
+summary: Ruby C extension for Linux GPIO
 test_files: []