pigpio_ffi 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7df185ca3334d723f7de61a087ae7ead59cab8ff44897de6a9d6cf17596ae86e
+  data.tar.gz: abacbdd2ba20c599513ca602d99f609fddec7f284a838d60511772c97a6d266d
+SHA512:
+  metadata.gz: 2b3f4222a72177044c47e949fe857dc6a9e03fa4922c6d5e1f8be19c622e421eebeb64bac0a4ac25d190c754c4789cd847424a6c02e779f44adebd6231022046
+  data.tar.gz: 6b0b5f1efe4dfdb8c6a6556b9c67cff2aaca4f56c2466a5a68436eb12e11515f06cfbf9a0460e922e2a129cc60f4a002f1a4f1f26cd0469d99ebc4e995415707

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 dino-rb
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,63 @@
+# pigpio_ffi 0.1.0
+
+This gem uses [FFI](https://github.com/ffi/ffi) to provide Ruby method bindings for the [pigpio](https://abyz.me.uk/rpi/pigpio/index.html) C library. This makes the Raspberry Pi GPIO pins usable in Ruby.
+
+NOTE: This is for Ruby on Linux, not for the Raspberry Pi Pico (W).
+
+## Installation
+
+Install pigpio with:
+```shell
+  sudo apt-get install pigpio
+```
+
+Install this gem as root:
+```shell
+  sudo gem install pigpio_ffi
+```
+
+Ruby scripts need to be run as root:
+```shell
+  sudo ruby my_script.rb
+```
+
+## Example
+
+```ruby
+require 'pigpio_ffi'
+
+PiGPIO.gpioInitialise
+PiGPIO.gpioSetMode(4, 1)
+
+10.times do
+  PiGPIO.gpioWrite(4, 1)
+  sleep 0.5
+  PiGPIO.gpioWrite(4, 0)
+  sleep 0.5
+end
+
+# This must be called or the script will block forever.
+PiGPIO.gpioTerminate
+```
+This will blink an LED attached to GPIO 4, every half second, for 10 seconds total.
+
+## Mapped Features
+
+  - Basic GPIO (set mode, read, write, alert on change)
+  - PWM (bitbang)
+  - Servo (bitbang)
+  - Waves (infrared and other protocols)
+  - I2C (still untested)
+  - SPI (still untested)
+
+## Documentation
+
+As much as possible, the class methods of `PiGPIO` follow the function names and argument formats of the pigpio C functions. These can be found in its documentation, located [here](https://abyz.me.uk/rpi/pigpio/download.html).
+
+**Exceptions**:
+
+  - Functions where one argument is a callback function. These translate to Ruby methods that take a block.
+  - Functions that take arrays and their length as separate arguments. These translate to Ruby methods where the length argument is omitted.
+  - Not all functions are mapped. I left out anything Ruby (or an existing gem) can already do, or any complex data processing that would be easier in Ruby anyway.
+
+TODO: List methods with different interfaces, and unmapped methods here.

data/lib/pigpio_ffi/advanced.rb

@@ -0,0 +1,29 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  # gpioNotifyOpen         not mapped.
+  # gpioNotifyClose        not mapped.
+	# gpioNotifyOpenWithSize not mapped.
+	# gpioNotifyBegin        not mapped.
+	# gpioNotifyPause        not mapped.
+
+  # gpioHardwareClock      not mapped.
+  # gpioHardwarePWM        not mapped.
+
+	# Args: gpio, steady time
+	attach_function :gpioGlitchFilter, [:uint, :uint], :int 
+
+	# Args: gpio, steady time, active time
+	attach_function :gpioNoiseFilter, [:uint, :uint, :uint], :int
+
+  # gpioSetPad	            not mapped.
+  # gpioGetPad	            not mapped.
+  # shell	                  not mapped.
+  # gpioSetISRFunc	        not mapped.
+  # gpioSetISRFuncEx	      not mapped.
+  # gpioSetSignalFunc	      not mapped.
+  # gpioSetSignalFuncEx	    not mapped.
+  # gpioSetGetSamplesFunc	  not mapped.
+  # gpioSetGetSamplesFuncEx	not mapped.
+end

data/lib/pigpio_ffi/basic.rb

@@ -0,0 +1,19 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  # Args: gpio, mode (0 = input, 1 = output, 2-7 = alternative)
+	attach_function :gpioSetMode, [:uint, :uint], :int
+	
+	# Args: gpio
+	attach_function :gpioGetMode, [:uint], :int
+
+  # Args, gpio, pud (0 = off, 1 = pulldown, 2 = pullup)
+  attach_function :gpioSetPullUpDown, [:uint, :uint], :int
+	
+	# Args: gpio
+	attach_function :gpioRead, [:uint], :int
+
+	# Args: gpio, level
+	attach_function :gpioWrite, [:uint, :uint], :int
+end

data/lib/pigpio_ffi/configuration.rb

@@ -0,0 +1,52 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  #
+  # GPIO callbacks do not trigger immediately.
+  # This batches them every X milliseconds. Defaults to 120.
+  #
+  # NOTE: Must be called before #gpioInitialise.
+  #
+  # Args: buffer in milliseconds
+  attach_function :gpioCfgBufferSize, [:uint], :int
+
+  #
+  # Configure the sampling rate for GPIO pins in microseconds.
+  # Defaults to 5us using the PCM peripheral.
+  #
+  # NOTE: Must be called before #gpioInitialise.
+  #
+  # Args: microseconds, peripheral (0=PWM, 1=PCM), source (deprecated, give 0)
+	attach_function :gpioCfgClock, [:uint, :uint, :uint], :int
+
+  # gpioCfgDMAchannel is deprecated.
+
+  #
+  # Configure pigpio to use specified DMA channels (0-14).
+  # Defaults:
+  #   BCM2711: 7  (primary), 6 (secondary)
+  #   Others:  14 (primary), 6 (secondary)
+  #
+  # NOTE: Must be called before #gpioInitialise.
+  #
+  # Args: DMA channel number
+  attach_function :gpioCfgDMAchannels, [:uint], :int
+
+  # gpioCfgPermission not mapped.
+  # gpioCfgSocketPort not mapped.
+  # gpioCfgInterfaces not mapped.
+
+  #
+  # NOTE: Must be called before #gpioInitialise.
+  #
+  # Args: memAllocMode (0-2)
+  #       0 = AUTO
+  #       1 = PAGEMAP
+  #       2 = MAILBOX
+  attach_function :gpioCfgMemAlloc, [:uint], :int
+
+  # gpioCfgNetAddr      not mapped.
+  # gpioCfgGetInternals not mapped.
+  # gpioCfgSetInternals not mapped.
+end

data/lib/pigpio_ffi/essential.rb

@@ -0,0 +1,7 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  attach_function :gpioInitialise, [], :int
+	attach_function :gpioTerminate, [], :int
+end

data/lib/pigpio_ffi/i2c.rb

@@ -0,0 +1,87 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  #
+  # Open a handle for I2C device at specified address (0-127).
+  # 
+	# Args:    i2cBus, i2cAddr, i2cFlags (set to 0)
+  # Returns: handle as integer
+	attach_function :i2cOpen, [:uint, :uint, :uint], :int
+
+  #
+  # Close an I2C device handle.
+  # 
+	# Args: handle
+	attach_function :i2cClose, [:uint], :int
+
+  # i2cWriteQuick not mapped.
+
+  # Args: handle, byte
+  attach_function :i2cWriteByte, [:uint, :uint8], :int
+
+  # Args: handle
+  attach_function :i2cReadByte, [:uint], :int
+
+  # i2cWriteByteData    not mapped.
+  # i2cWriteWordData    not mapped.
+  # i2cReadByteData     not mapped.
+  # i2cReadWordData     not mapped.
+  # i2cProcessCall      not mapped.
+  # i2cWriteBlockData   not mapped.
+  # i2cReadBlockData    not mapped.
+  # i2cBlockProcessCall not mapped.
+
+  # 
+  # Read up to 32 bytes from a given I2C address (as handle), and start register.
+	#
+	# Don't call this directly.
+  attach_function :_i2cReadI2CBlockData, :i2cReadI2CBlockData, [:uint, :uint, :pointer], :int
+  #
+  # Call this instead.
+  def self.i2cReadI2CBlockData(handle, start_register, length)
+    raise ArgumentError, "Cannot read more than 32 I2C bytes" if length > 32
+    buffer_pointer = FFI::MemoryPointer.new(:uint8, length)
+
+    # Read it and convert it to a Ruby array.
+    self._i2cReadI2CBlockData(handle, start_register, buffer_pointer)
+    bytes = buffer_pointer.read_array_of_type(:uint8, length)
+  end
+
+  # 
+  # Write up to 32 bytes to a given I2C address (as handle), and start register.
+  #
+	# Don't call this directly.
+  attach_function :_i2cWriteI2CBlockData, :i2cWriteI2CBlockData, [:uint, :uint, :pointer], :int
+  #
+  # Call this instead.
+  def self.i2cWriteI2CBlockData(handle, start_register, byte_array)
+    # Do some validation.
+    raise ArgumentError, "Cannot write more than 32 I2C bytes" if byte_array > 32
+    byte_array.each do |element|
+      raise ArgumentError, "Byte values must be within 0x00 and 0xFF" if (element > 0xFF || element < 0x00)
+    end
+
+    # Copy the array to the pointer location.
+    buffer_pointer = FFI::MemoryPointer.new(:uint8, byte_array.length)
+    buffer_pointer.write_array_of_type(:uint8, byte_array)
+
+    # Write it.
+    self._i2cReadI2CBlockData(handle, start_register, buffer_pointer)
+  end
+  
+  # i2cReadDevice   not mapped.
+  # i2cWriteDevice  not mapped.
+
+  #
+  # When enabled, this sends repeated start bits instead of stop.
+  # 
+  # Args: setting (0=off, 1=on)
+  attach_function :i2cSwitchCombined, [:uint], :void
+
+  # i2cSegments not mapped.
+  # i2cZip      not mapped.
+  # bbI2COpen   not mapped yet.
+  # bbI2CClose  not mapped yet.
+  # bbI2CZip    not mapped yet.
+end

data/lib/pigpio_ffi/intermediate.rb

@@ -0,0 +1,64 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+	# Pulse a GPIO by holding it at level for pulse length, then resetting to not level.
+	# Args: gpio, pulse length, level
+	attach_function :gpioTrigger, [:uint, :uint, :uint], :int
+
+	# gpioSetWatchdog not mapped.
+
+	# Returns: bit mask of GPIO states
+	attach_function :gpioRead_Bits_0_31, [], :uint32 
+
+	# Returns: bit mask of GPIO states
+	attach_function :gpioRead_Bits_32_53, [], :uint32 
+
+	# Arg: bit mask of pins to clear (1 = clear, 0 = leave alone)
+	attach_function :gpioWrite_Bits_0_31_Clear, [:uint32], :int 
+
+	# Arg: bit mask of pins to clear (1 = clear, 0 = leave alone)
+	attach_function :gpioWrite_Bits_32_53_Clear, [:uint32], :int 
+
+	# Arg: bit mask of pins to clear (1 = set, 0 = leave alone)
+	attach_function :gpioWrite_Bits_0_31_Set, [:uint32], :int 
+
+	# Arg: bit mask of pins to clear (1 = set, 0 = leave alone)
+	attach_function :gpioWrite_Bits_32_53_Set, [:uint32], :int 
+
+	#
+	# Observe/listen for changes on a GPIO.
+	# NOTE: Use the last method defined in this section.
+	#
+	# Callback receives args: gpio, value, tick (microseconds since boot, 72 minute overflow)
+  callback :alert_callback, [:uint, :uint, :uint], :void
+  #
+	# Args: gpio, callback as proc (nil to disable)
+	attach_function :_gpioSetAlertFunc, :gpioSetAlertFunc, [:uint, :alert_callback], :int
+	#
+	# Call this one with a block.
+	def self.gpioSetAlertFunc(gpio, &block)
+		self._gpioSetAlertFunc(gpio, &block)
+	end
+
+	# gpioSetAlertFuncEx not mapped.
+
+	#
+	# Register a callback with one of the hardware timers (0-9).
+	# NOTE: Use the last method defined in this section.
+	# 
+	# Callback receives no args.
+  callback :alert_callback, [], :void
+  #
+	# Args: timer index, millisecond interval, callback as proc (nil to disable)
+	attach_function :_gpioSetTimerFunc, :gpioSetTimerFunc, [:uint, :uint], :int
+	#
+	# Call this one with a block.
+	def self.gpioSetTimerFunc(timer, millis, &block)
+		self._gpioSetTimerFunc(gpio, millis, &block)
+	end
+
+	# gpioSetTimerFuncEx not mapped.
+	# gpioStartThread 	 not mapped.
+	# gpioStopThread  	 not mapped.
+end

data/lib/pigpio_ffi/pwm.rb

@@ -0,0 +1,25 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  # Args: gpio, dutycycle (0-range)
+	attach_function :gpioPWM, [:uint, :uint], :int
+	
+	# Args: gpio
+	attach_function :gpioGetPWMdutycycle, [:uint], :int
+	
+	# Args: gpio, range (25-40000)
+	attach_function :gpioSetPWMrange, [:uint, :uint], :int
+
+	# Args: gpio
+	attach_function :gpioGetPWMrange, [:uint], :int
+
+	# Args: gpio
+	attach_function :gpioGetPWMrealRange, [:uint], :int
+	
+	# Args: gpio, frequency (In Hz, matches nearest available. See pigpio docs for more)
+  attach_function :gpioSetPWMfrequency, [:uint, :uint], :int 
+
+	# Args: gpio
+	attach_function :gpioGetPWMfrequency, [:uint], :int
+end

data/lib/pigpio_ffi/servo.rb

@@ -0,0 +1,10 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+	# Args: gpio, pulsewidth (in microseconds)
+	attach_function :gpioServo, [:uint, :uint], :int
+
+	# Args: gpio
+	attach_function :gpioGetServoPulsewidth, [:uint, :uint], :int
+end

data/lib/pigpio_ffi/spi.rb

@@ -0,0 +1,87 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+	#
+  # Open a handle for SPI device on the bus
+  # 
+	# Args: spiChan, baud, spiFlags (see pigpio docs)
+	# 			spiFlags control mode, chip select, LSB/MSB etc.
+	#		
+  # Returns: handle as integer
+	attach_function :spiOpen, [:uint, :uint32, :uint32], :int
+
+	#
+  # Close an SPI device handle.
+  # 
+	# Args: handle
+	attach_function :i2cClose, [:uint], :int
+
+  # 
+  # Read length bytes from the given SPI handle.
+	#
+	# Don't call this directly.
+	# Args: handle, buffer, count
+  attach_function :_spiRead, :spiRead, [:uint, :pointer, :uint], :int
+  #
+  # Call this instead.
+  def self.spiRead(handle, length)
+		# Limited to word sizes of 8 bits.
+    buffer_pointer = FFI::MemoryPointer.new(:uint8, length)
+
+    # Read it and convert it to a Ruby array.
+    self._spiRead(handle, buffer_pointer, length)
+    bytes = buffer_pointer.read_array_of_type(:uint8, length)
+  end
+
+  # 
+  # Write bytes to the given SPI handle.
+  #
+	# Don't call this directly.
+  attach_function :_spiWrite, :spiWrite, [:uint, :pointer, :uint], :int
+  #
+  # Call this instead.
+  def self.spiWrite(handle, byte_array)
+		# Do some validation.
+    byte_array.each do |element|
+      raise ArgumentError, "Byte values must be within 0x00 and 0xFF" if (element > 0xFF || element < 0x00)
+    end
+
+    # Copy the array to the pointer location.
+    buffer_pointer = FFI::MemoryPointer.new(:uint8, byte_array.length)
+    buffer_pointer.write_array_of_type(:uint8, byte_array)
+
+    # Write it.
+    self._spiWrite(handle, buffer_pointer, buffer_pointer.length)
+  end
+
+	# 
+  # Xfer bytes from the SPI handle. Reads as many bytes as the legnth of the tx_buffer.
+  #
+	# Don't call this directly.
+  attach_function :_spiXfer, :spiXfer, [:uint, :pointer, :pointer, :uint], :int
+  #
+  # Call this instead.
+  def self.spiXfer(handle, tx_array)
+		tx_array.each do |element|
+			raise ArgumentError, "Byte values must be within 0x00 and 0xFF" if (element > 0xFF || element < 0x00)
+		end
+
+		# Copy the tx array to the pointer location.
+		tx_pointer = FFI::MemoryPointer.new(:uint8, tx_array.length)
+    tx_pointer.write_array_of_type(:uint8, tx_array)
+
+		# Make pointer for the receive buffer.
+		rx_pointer = FFI::MemoryPointer.new(:uint8, tx_array.length)
+
+		# Transfer.
+		self._spiWrite(handle, buffer_pointer, buffer_pointer.length)
+
+    # Read bytes from the rx pointer.
+    rx_bytes = rx_pointer.read_array_of_type(:uint8, tx_array.length)
+  end
+
+	# bbSPIOpen  not mapped.
+	# bbSPIClose not mapped.
+	# bbSPIXfer  not mapped.
+end

data/lib/pigpio_ffi/utilities.rb

@@ -0,0 +1,25 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  # Args: delay time in microseconds
+  # Returns: actual delay time in microseconds
+	attach_function :gpioDelay, [:uint32], :uint32
+
+  #
+  # Returns: current system tick (microseconds with 72 miniute rollover)
+	attach_function :gpioTick, [], :uint32
+
+  # Returns: integer corresponding to Raspberry Pi hardware revision
+  attach_function :gpioHardwareRevision, [], :uint
+
+  # Returns: pigpio version
+  attach_function :gpioVersion, [], :uint
+
+  # getBitInBytes not mapped.
+  # putBitInBytes not mapped.
+  # gpioTime      not mapped.
+  # gpioSleep     not mapped.
+  # time_time     not mapped.
+  # time_sleep    not mapped.
+end

data/lib/pigpio_ffi/version.rb

@@ -0,0 +1,3 @@
+module PiGPIO
+  VERSION = "0.1.0"
+end

data/lib/pigpio_ffi/waves.rb

@@ -0,0 +1,99 @@
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+  
+  #
+	# Struct for holding a single pulse. Given as a hash in Ruby.
+	# gpioOn and gpioOff are bitmasks 32 bits long, NOT GPIO numbers.
+  class WavePulse < FFI::Struct
+    layout  :gpioOn, :uint32,
+            :gpioOff, :uint32,
+            :usDelay, :uint32
+  end
+
+	attach_function :gpioWaveClear, [], :int
+	attach_function :gpioWaveAddNew, [], :int
+	
+	#
+	# Don't call this directly.
+	attach_function :_gpioWaveAddGeneric, :gpioWaveAddGeneric, [:uint, :pointer], :int
+	#
+	# Call this instead. No length arg like C function.
+	# Args: array of pulse hashes.
+	def self.gpioWaveAddGeneric(pulses=[])
+		pulses_pointer = FFI::MemoryPointer.new(WavePulse, pulses.length)
+		pulse_structs = pulses.length.times.collect do |i|
+			WavePulse.new(pulses_pointer + i * WavePulse.size)
+		end
+		pulses.each_with_index do |hash, i|
+			pulse_structs[i][:gpioOn]  = hash[:gpioOn]
+			pulse_structs[i][:gpioOff] = hash[:gpioOff]
+			pulse_structs[i][:usDelay] = hash[:usDelay] 
+		end
+	  self._gpioWaveAddGeneric(pulses.length, pulses_pointer)
+	end
+	
+	# gpioWaveAddSerial not mapped.
+
+	# Returns: wave_id        
+	attach_function :gpioWaveCreate, [], :int
+
+	# gpioWaveCreatePad not mapped.
+
+	# Args: wave_id 
+	attach_function :gpioWaveDelete, [:uint], :int
+
+	# Args: wave_id, mode (0 = oneshot, 1 = repeat, 2 = oneshot sync, 3 = repeat sync)
+	attach_function :gpioWaveTxSend, [:uint, :uint], :int
+	
+	#
+	# Don't call this directly.
+	attach_function :_gpioWaveChain, :gpioWaveChain, [:pointer, :uint], :int
+	#
+	# Call this instead. No length arg like C function.
+	# Args: array of wave_ids to send in order.
+	def self.gpioWaveChain(wave_id_array=[])
+    # NOTE: Should add validation here? Each array element should be a byte.
+    # Maximum number of bytes should be 600.
+
+    # Just pack the byte array into a string. Gets mapped to char * in C.
+    string = wave_id_array.pack('C*')
+	  self._gpioWaveChain(string, wave_id_array.length)
+	end
+  
+	# Returns: wave_id of wave being transmitted
+	attach_function :gpioWaveTxAt, [], :int
+
+	# Returns: 1 if transmitting, 0 otherwise
+	attach_function :gpioWaveTxBusy, [], :int
+
+	# Returns: 0 if OK
+	attach_function :gpioWaveTxStop, [], :int
+
+	# Returns: length (in microseconds) of current wave
+	attach_function :gpioWaveGetMicros, [], :int
+
+	# Returns: length of longest wave since initialise (in terms of microseconds)
+	attach_function :gpioWaveGetHighMicros, [], :int
+
+	# Returns: length of longest wave possible (in terms of microseconds)
+	attach_function :gpioWaveGetMaxMicros, [], :int
+
+	# Returns: length (in pulses) of current wave
+	attach_function :gpioWaveGetPulses, [], :int
+
+	# Returns: length of longest wave since initialise (in terms of pulses)
+	attach_function :gpioWaveGetHighPulses, [], :int
+
+	# Returns: length of longest wave possible (in terms of pulses)
+	attach_function :gpioWaveGetMaxPulses, [], :int
+
+	# Returns: length of longest wave since initialise (in terms of DMA control blocks)
+	attach_function :gpioWaveGetCbs, [], :int
+
+	# Returns: length of longest wave possible (in terms of DMA control blocks)
+	attach_function :gpioWaveGetHighCbs, [], :int
+
+	# Returns: length of longest wave possible (in terms of DMA control blocks)
+	attach_function :gpioWaveGetMaxCbs, [], :int
+end

data/lib/pigpio_ffi.rb

@@ -0,0 +1,40 @@
+require 'ffi'
+
+#
+# Each file adds methods to the PiGPIO module, corresponding to a named
+# section of the pigpgio C interface docs, located here:
+# https://abyz.me.uk/rpi/pigpio/cif.html
+# 
+# NOTE: nothing from the following sections is mapped:
+# Custom, Events, Files, Scripts, Serial, I2C/SPI Slave, Expert
+#
+require_relative 'pigpio_ffi/version'
+require_relative 'pigpio_ffi/essential'
+require_relative 'pigpio_ffi/basic'
+require_relative 'pigpio_ffi/pwm'
+require_relative 'pigpio_ffi/servo'
+require_relative 'pigpio_ffi/intermediate'
+require_relative 'pigpio_ffi/advanced'
+require_relative 'pigpio_ffi/i2c'
+require_relative 'pigpio_ffi/spi'
+require_relative 'pigpio_ffi/waves'
+require_relative 'pigpio_ffi/utilities'
+require_relative 'pigpio_ffi/configuration'
+
+#
+# Additional convenience and helper methods added here.
+# 
+module PiGPIO
+	extend FFI::Library
+	ffi_lib 'pigpio'
+
+  # Helper to handle systick integer rollover calculation.
+  def self.gpioTicksSince(old_time)
+    current_time = gpioTick
+    if current_time < old_time
+      (0xFFFF - old_time) + current_time
+    else
+      current_time - old_time
+    end
+  end
+end

data/pigpio_ffi.gemspec

@@ -0,0 +1,16 @@
+require_relative 'lib/pigpio_ffi/version'
+
+Gem::Specification.new do |s|
+  s.name        = 'pigpio_ffi'
+  s.version     = PiGPIO::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = "FFI bindings for pigpio C library on Raspberry Pi devices"
+  s.description = "Use your Raspberry Pi GPIO pins in Ruby. This gem uses FFI to provide Ruby bindings for the pigpio C library on compatible Raspberry Pi Devices."
+  s.authors     = ["vickash"]
+  s.email       = 'vickashmahabir@gmail.com'
+  s.files       =  Dir['**/*']
+  s.homepage    = 'https://github.com/dino-rb/pigpio_ffi'
+  s.metadata    = { "source_code_uri" => "https://github.com/dino-rb/pigpio_ffi" }
+
+  s.add_dependency 'ffi'
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: pigpio_ffi
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- vickash
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-03-31 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: ffi
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Use your Raspberry Pi GPIO pins in Ruby. This gem uses FFI to provide
+  Ruby bindings for the pigpio C library on compatible Raspberry Pi Devices.
+email: vickashmahabir@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/pigpio_ffi.rb
+- lib/pigpio_ffi/advanced.rb
+- lib/pigpio_ffi/basic.rb
+- lib/pigpio_ffi/configuration.rb
+- lib/pigpio_ffi/essential.rb
+- lib/pigpio_ffi/i2c.rb
+- lib/pigpio_ffi/intermediate.rb
+- lib/pigpio_ffi/pwm.rb
+- lib/pigpio_ffi/servo.rb
+- lib/pigpio_ffi/spi.rb
+- lib/pigpio_ffi/utilities.rb
+- lib/pigpio_ffi/version.rb
+- lib/pigpio_ffi/waves.rb
+- pigpio_ffi.gemspec
+homepage: https://github.com/dino-rb/pigpio_ffi
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/dino-rb/pigpio_ffi
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.8
+signing_key:
+specification_version: 4
+summary: FFI bindings for pigpio C library on Raspberry Pi devices
+test_files: []