denko-piboard 0.13.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 7bd44c89b18336b4d540b81e6fd7e74cf3dd51a733f148e9acd8278795942249
+  data.tar.gz: 02d317de93789676488866e9560ca4d5da91014f47509029991b4be31ab20c9f
+SHA512:
+  metadata.gz: c8bb78c2b3e62273b21ec520d35ba54465d3edf8f2e93811f7aaca0aca1e089152a7a0479715754d77301bc8ad938a39086a8bb1cb127566b5ac9c126946956d
+  data.tar.gz: d305d28242a97dd14c546516c5ba4b5853e249822981c59ed55e1fb949573524c3744e1a1b2f7889658de8afcedeb469b018acc5dc233fb0e29798a923827e33

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 denko-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,165 @@
+# denko-piboard 0.13.0
+
+### Raspberry Pi GPIO in Ruby
+
+This gem adds support for the Raspberry Pi GPIO interface to the [`denko`](https://github.com/denko-rb/denko) gem. Unlike the main gem, which requires an external microcontroller, this lets you to connect peripherals directly to the Pi.
+
+`Denko::PiBoard` is a drop-in replacement for `Denko::Board`, which would represent a connected micrcontroller. Everything maps to the Pi's built-in GPIO pins instead.
+
+**Note:** This is not for the Raspberry Pi Pico (W) / RP2040. That microcontroller works with the main gem.
+
+## Example
+Create a script, `led_button.rb`:
+
+```ruby
+require 'denko/piboard'
+
+# Board instance for the Pi.
+board = Denko::PiBoard.new
+
+# LED connected to GPIO4.
+led = Denko::LED.new(board: board, pin: 4)
+
+# Momentary button connected to GPIO17, using internal pullup.
+button = Denko::DigitalIO::Button.new(board: board, pin: 17, pullup: true)
+
+# Led on when button is down (0)
+button.down do
+  puts "Button down"
+  led.on
+end
+
+# Led is off when button is up (1)
+button.up do
+  puts "Button up"
+  led.off
+end
+
+# Sleep main thread. Ctrl+C to quit.
+sleep
+```
+
+Run it:
+```shell
+ruby led_button.rb
+```
+#### More Examples
+Some Pi-specific code is shown in this gem's [examples](examples) folder, but most examples are in the [main gem](https://github.com/denko-rb/denko/tree/master/examples). They must be modified to work with the Pi's GPIO:
+
+1. Replace setup code:
+  ```ruby
+    # Replace this:
+    require 'bundler/setup'
+    require 'denko'
+    # With this:
+    require 'denko/piboard'
+
+    # Replace this:
+    connection = Denko::Connection::Serial.new()
+    board = Denko::Board.new()
+    # With this:
+    board = Denko::PiBoard.new
+  ```
+
+2. Update GPIO/pin numbers as needed. Raspberry Pi pinouts can be found [here](https://pinout.xyz/).
+  
+**Note:** Not all features from all examples are implemented yet, nor can be implemented. See [Features](#features) below.
+
+## Installation
+This gem depends on the [pigpio library](https://github.com/joan2937/pigpio) and [pigpio gem](https://github.com/nak1114/ruby-extension-pigpio), which provides Ruby bindings, as well as [libgpiod](https://git.kernel.org/pub/scm/libs/libgpiod/libgpiod.git).
+
+#### 1. Install pigpio and libgpiod packages
+```shell
+sudo apt install pigpio libgpiod-dev
+```
+
+#### 2. Install pigpio gem
+The `pigpio` gem has a couple bugs. Until fixes are merged, please install from [this fork](https://github.com/vickash/ruby-extension-pigpio):
+```shell
+git clone https://github.com/vickash/ruby-extension-pigpio.git
+cd ruby-extension-pigpio
+gem build
+gem install ruby-extension-pigpio-0.1.11.gem
+```
+
+#### 3. Install denko gem
+This gem is very new. It __will not__ work with the version of `denko` (0.11.3) currently available from RubyGems. Install the latest version (future 0.13.0) from the master branch instead:
+```shell
+git clone https://github.com/denko-rb/denko.git
+cd denko
+git submodule init
+git submodule update
+gem build
+gem install denko-0.13.0.gem
+```
+
+#### 4. Install denko/piboard gem
+Again, since this gem is so new, install from the latest master branch:
+```shell
+git clone https://github.com/denko-rb/denko-piboard.git
+cd denko-piboard
+gem build
+gem install denko-piboard-0.13.0.gem
+```
+
+**Note:** `sudo` may be needed before `gem install` if using the preinstalled Ruby on a Raspberry Pi.
+
+## Pi Setup
+Depending on your Pi setup, libgpiod may limit GPIO access to the `root` user. If this is the case, Ruby scripts will fail with a `libgpiod` error. To give your user account permission to access GPIO, add it to the `gpio` group.
+```
+sudo usermod -a -G gpio YOUR_USERNAME
+```
+
+I2C, SPI and the hardware UART are disabled on the Pi by default. Enable them with the built in utility:
+```shell
+sudo raspi-config
+```
+
+Select "Interfacing Options" from the menu and enable as needed. More info in the [Features](#features) section.
+
+#### pigpiod
+The `pigpio` package includes `pigpiod`, which runs in the background as root, providing GPIO access. Ruby scripts won't work if it isn't running. You should only need to start it once per boot. You can automate it, or start manually with:
+```shell
+sudo pigpiod -s 10
+```
+
+**Note:** `-s 10` sets `pigpiod` to tick every 10 microseconds, lowering CPU use. Valid values are: 1, 2, 4, 5, 8, 10 (5 default).
+
+## Features
+
+### Already Implemented
+  - Internal Pull Down/Up
+  - Digital Out
+  - Digital In
+  - PWM Out (use on any pin disables PCM out, cancels Servo on same pin)
+  - Servo   (use on any pin disables PCM out, cancels PWM Out on same pin)
+  - ToneOut (uses waves, one at a time per board, cancels any Infrared Out)
+  - Infrared Out (uses waves, one at a time per board, cancels any Tone Out)
+  - DHT Class Temperature + Humidity Sensors
+  - I2C
+    - Must enable with `raspi-config` before use. Instructions [here](https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/configuring-i2c).
+    - I2C hardware clock cannot be set dynamically, like a microcontroller. Must set in `/boot/config.txt`. Default is 100 kHz. 400 kHz recommended if transferring a lot of data, like with SSD1306 OLED. See [here](https://www.raspberrypi-spy.co.uk/2018/02/change-raspberry-pi-i2c-bus-speed/) for instructions.
+
+### Partially Implemented
+  - SPI
+    - Must enable with `raspi-config` before use. Insturctions [here](https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/configuring-spi).
+    - Only Uses SPI1 interface, not SPI0.
+    - Does not bind CE pins according to GPIO pinout. Any pin can be used for chip enable.
+    - SPI modes 1 and 3 may not work.
+    - No listeners yet.
+
+### To Be Implemented
+  - OneWire
+  - Hardware UART
+  - BitBang I2C
+  - BitBang SPI 
+  - BitBang UART
+  - WS2812
+
+### Differences
+  - Listeners are still polled in a thread, but always at 1ms.
+  - pigpio has very fast native input callbacks available, but events are not received in order on a global basis, only per pin. This creates issues where event order between pins is important (like a RotaryEncoder). May expose this functionality for SinglePin components later.
+
+### Incompatible
+  - EEPROM (Use the filesystem for persistence instead)
+  - Analog IO (No analog pins on Raspberry Pi. Use ADC or DAC over I2C or SPI)

data/Rakefile

@@ -0,0 +1,5 @@
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "gpiod" do |ext|
+  ext.lib_dir = "lib/gpiod"
+end

data/denko_piboard.gemspec

@@ -0,0 +1,21 @@
+require_relative 'lib/denko/piboard_version'
+
+Gem::Specification.new do |s|
+  s.name        = 'denko-piboard'
+  s.version     = Denko::PiBoard::VERSION
+  s.licenses    = ['MIT']
+  s.summary     = "Use Raspberry Pi built-in GPIO as a Board class with the denko gem"
+  s.description = "Denko::PiBoard is a drop-in replacement for Denko::Board. Use denko features and component classes to be used directly on a Raspberry Pi."
+
+  s.authors     = ["vickash"]
+  s.email       = 'mail@vickash.com'
+  s.files       =  Dir['**/*'].reject { |f| f.match /.gem\z/}
+  s.homepage    = 'https://github.com/denko-rb/denko-piboard'
+  s.metadata    = { "source_code_uri" => "https://github.com/denko-rb/denko-piboard" }
+  
+  # libgpio C extension
+  s.extensions = %w[ext/gpiod/extconf.rb]
+
+  s.add_dependency 'pigpio', '~> 0.1'
+  s.add_dependency 'denko',  '~> 0.13'
+end

data/examples/pi_system_monitor.rb

@@ -0,0 +1,58 @@
+#
+# This example uses an SSD1306 OLED display, connected to the Pi's I2C1 interface.
+# I2C1 pins are GPIO2 (SDA) and GPIO3 (SCL).
+# 
+# CPU usage is measured using `mpstat`. To install it:
+#     sudo apt install sysstat
+#
+# RAM usage is measured using `free`.
+#
+# Each loop, the OLED refreshes, showing date, time, CPU usage and RAM usage.
+#
+require 'denko/piboard'
+
+# Special character that fills a 4x6 rectangle.
+# Used to make bar graphs for CPU and RAM usage.
+BAR_ELEMENT = [0x00, 0x7E, 0x7E, 0x7E, 0x00]
+
+board = Denko::PiBoard.new
+i2c = Denko::I2C::Bus.new(board: board, pin: :SDA)
+
+oled = Denko::Display::SSD1306.new(bus: i2c, rotate: true)
+canvas = oled.canvas
+
+# Only do this once since total RAM won't change.
+total_ram = `free -h | awk 'NR==2 {gsub("Mi", "", $2); print $2}'`
+total_ram = total_ram.to_i
+ram_bar_factor = total_ram / 25.0
+
+loop do
+  # CPU Usage (automatically delays for 1 second)
+  mpstat_result = `mpstat -P ALL 1 1 | awk '/^Average:/ && ++count == 2 {print 100 - $12"%"}'`
+  cpu_percent = mpstat_result.chop.to_f
+  
+  canvas.clear
+  canvas.text_cursor = [0, 16]
+  canvas.print "CPU Usage:  #{('%.3f' % cpu_percent).rjust(8, ' ')}%"
+  
+  canvas.text_cursor = [0, 24]
+  (cpu_percent / 4).ceil.times { canvas.raw_char(BAR_ELEMENT) }
+  
+  # RAM Usage
+  ram_usage = `free -h | awk 'NR==2 {gsub("Mi", "", $3); print $3}'`
+  ram_usage = ram_usage.to_i
+
+  canvas.text_cursor = [0, 40]
+  ram_string = "#{ram_usage}/#{total_ram}MB"
+  canvas.print "RAM Usage:#{ram_string.rjust(11, ' ')}"
+  
+  canvas.text_cursor = [0, 48]
+  (ram_usage / ram_bar_factor).ceil.times { canvas.raw_char(BAR_ELEMENT) }
+  
+  # Date and time just before write.
+  canvas.text_cursor = [0,0]
+  canvas.print(Time.now.strftime('%a %b %d %-l:%M %p'))
+  
+  # Only refresh the area in use.
+  oled.draw(0, 127, 0, 56)
+end

data/ext/gpiod/extconf.rb

@@ -0,0 +1,9 @@
+require 'mkmf'
+
+#
+# Need libgpiod-dev installed.
+#   sudo apt install libgpiod-dev
+#
+$libs += " -lgpiod"
+
+create_makefile('gpiod/gpiod')

data/ext/gpiod/gpiod.c

@@ -0,0 +1,179 @@
+#include <ruby.h>
+#include <gpiod.h>
+
+#define GPIO_CHIP_NAME "gpiochip0"
+
+static struct gpiod_chip *chip;
+
+// Save mapping of lowest 32 GPIOs to gpiod_line structs.
+static struct gpiod_line *lines[32] = { NULL };
+
+// Input and output values.
+static int gpio_number;
+static int gpio_value;
+static int return_value;
+
+static VALUE open_chip(VALUE self) {
+  chip = gpiod_chip_open_by_name(GPIO_CHIP_NAME);
+  if (!chip) {
+    rb_raise(rb_eRuntimeError, "libgpiod error: Could not open GPIO chip");
+    return Qnil;
+  }
+  return Qnil;
+}
+
+static VALUE close_chip(VALUE self) {
+  gpiod_chip_close(chip);
+  return Qnil;
+}
+
+static void validate_gpio_number(int gpio_number) {
+  if ((gpio_number < 0) || (gpio_number > 31)) {
+    VALUE error_message = rb_sprintf("libgpiod error: GPIO line (%d) out of range. Valid range is 0..31", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+  }
+}
+
+static void validate_gpio_value(int value) {
+  if (!((value == 0) || (value == 1))) {
+    VALUE error_message = rb_sprintf("libgpiod error: GPIO value (%d) out of range. Valid values are 0 or 1", value);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+  }
+}
+
+static VALUE open_line_output(VALUE self, VALUE gpio) {
+  gpio_number = NUM2INT(gpio);
+  validate_gpio_number(gpio_number);
+
+  lines[gpio_number] = gpiod_chip_get_line(chip, gpio_number);
+  if (!lines[gpio_number]) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not get GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  
+  return_value = gpiod_line_request_output(lines[gpio_number], "GPIOD_RB", 0);
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not request output for GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  
+  return Qnil;
+}
+
+static VALUE set_value(VALUE self, VALUE gpio, VALUE value) {
+  gpio_number = NUM2INT(gpio);
+  validate_gpio_number(gpio_number);
+  gpio_value = NUM2INT(value);
+  validate_gpio_value(gpio_value);
+
+  return_value = gpiod_line_set_value(lines[gpio_number], gpio_value);
+  
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not set value %d on GPIO line %d", gpio_value, gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+
+  return value;
+}
+
+static VALUE open_line_input(VALUE self, VALUE gpio) {
+  gpio_number = NUM2INT(gpio);
+  validate_gpio_number(gpio_number);
+  
+  lines[gpio_number] = gpiod_chip_get_line(chip, gpio_number);
+  if (!lines[gpio_number]) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not get GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  
+  return_value = gpiod_line_request_input(lines[gpio_number], "GPIOD_RB");
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not request input for GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  
+  return Qnil;
+}
+
+static VALUE get_value(VALUE self, VALUE gpio) {
+  gpio_number = NUM2INT(gpio);
+  validate_gpio_number(gpio_number);
+  
+  return_value = gpiod_line_get_value(lines[gpio_number]);
+  
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not get value from GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  
+  return INT2NUM(return_value);
+}
+
+static VALUE close_line(VALUE self, VALUE gpio) {
+  gpio_number = NUM2INT(gpio);
+  validate_gpio_number(gpio_number);
+
+  // Only try to close the line if it was opened before.
+  if (lines[gpio_number] == NULL) return Qnil;
+
+  gpiod_line_release(lines[gpio_number]);
+  lines[gpio_number] = NULL;  
+  return Qnil;
+}
+
+static VALUE set_value_raw(VALUE self, VALUE gpio, VALUE value) {
+  gpio_number = NUM2INT(gpio);
+  gpio_value = NUM2INT(value);
+
+  return_value = gpiod_line_set_value(lines[gpio_number], gpio_value);
+  
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not set value %d on GPIO line %d", gpio_value, gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  return value;
+}
+
+static VALUE get_value_raw(VALUE self, VALUE gpio) {
+  gpio_number = NUM2INT(gpio);
+  
+  return_value = gpiod_line_get_value(lines[gpio_number]);
+  
+  if (return_value < 0) {
+    gpiod_chip_close(chip);
+    VALUE error_message = rb_sprintf("libgpiod error: Could not get value from GPIO line %d", gpio_number);
+    rb_raise(rb_eRuntimeError, "%s", StringValueCStr(error_message));
+    return Qnil;
+  }
+  return INT2NUM(return_value);
+}
+
+void Init_gpiod(void) {
+  VALUE mDenko  = rb_define_module("Denko");
+  VALUE mGPIOD = rb_define_module_under(mDenko, "GPIOD");
+  rb_define_singleton_method(mGPIOD, "open_chip",        open_chip,        0);
+  rb_define_singleton_method(mGPIOD, "close_chip",       close_chip,       0);
+  rb_define_singleton_method(mGPIOD, "open_line_output", open_line_output, 1);
+  rb_define_singleton_method(mGPIOD, "set_value",        set_value,        2);
+  rb_define_singleton_method(mGPIOD, "open_line_input",  open_line_input,  1);
+  rb_define_singleton_method(mGPIOD, "get_value",        get_value,        1);
+  rb_define_singleton_method(mGPIOD, "close_line",       close_line,       1);
+
+  // These do no validation.
+  rb_define_singleton_method(mGPIOD, "set_value_raw",    set_value_raw,    2);
+  rb_define_singleton_method(mGPIOD, "get_value_raw",    get_value_raw,    1);
+}

data/lib/denko/piboard.rb

@@ -0,0 +1,11 @@
+require_relative '../gpiod'
+require_relative 'piboard_version'
+require_relative 'piboard_map'
+require_relative 'piboard_base'
+require_relative 'piboard_core'
+require_relative 'piboard_pulse'
+require_relative 'piboard_servo'
+require_relative 'piboard_tone'
+require_relative 'piboard_infrared'
+require_relative 'piboard_i2c'
+require_relative 'piboard_spi'

data/lib/denko/piboard_base.rb

@@ -0,0 +1,81 @@
+require 'denko'
+require 'pigpio'
+
+module Denko
+  class PiBoard
+    include Pigpio::Constant
+      
+    attr_reader :high, :low, :pwm_high
+
+    def initialize
+      # On 64-bit systems there's a pigpio bug where wavelengths are doubled.
+      @aarch64 = RUBY_PLATFORM.match(/aarch64/)
+
+      # Pin state
+      @pins          = []
+      @pwms          = []
+
+      # Listener state
+      @pin_listeners  = []
+      @listen_mutex   = Mutex.new
+      @listen_states  = Array.new(32) { 0 }
+      @listen_thread  = nil
+      @listen_reading = 0
+      
+      # PiGPIO callback state. Unused for now.
+      @pin_callbacks = []
+
+      # Logic levels
+      @low           = 0
+      @high          = 1
+      @pwm_high      = 255
+
+      # Use the pigpiod interface directly.
+      @pi_handle = Pigpio::IF.pigpio_start
+      exit(-1) if @pi_handle < 0
+      
+      # Open the libgpiod interface too.
+      Denko::GPIOD.open_chip
+    end
+
+    def finish_write
+      Pigpio::IF.pigpio_stop(@pi_handle)
+      Denko::GPIOD.close_chip
+    end
+
+    #
+    # Use standard Subcomponents behavior.
+    #
+    include Behaviors::Subcomponents
+
+    def update(pin, message, time=nil)
+      if single_pin_components[pin]
+        single_pin_components[pin].update(message)
+      end
+    end
+
+    private
+
+    attr_reader :pi_handle, :wave
+
+    def get_gpio(pin)
+      @pins[pin] ||= Pigpio::UserGPIO.new(@pi_handle, pin)
+    end
+    
+    def pwm_clear(pin)
+      @pwms[pin] = nil
+    end
+
+    def new_wave
+      stop_wave
+      @wave = Pigpio::Wave.new(pi_handle)
+    end
+
+    def stop_wave
+      return unless wave
+      wave.tx_stop
+      wave.clear
+      @wave = nil
+    end
+  end
+end

data/lib/denko/piboard_core.rb

@@ -0,0 +1,171 @@
+module Denko
+  class PiBoard
+    # CMD = 0
+    def set_pin_mode(pin, mode=:input, glitch_time=nil)
+      # Close the line in libgpiod, if was already open.
+      Denko::GPIOD.close_line(pin)
+
+      pwm_clear(pin)
+      gpio = get_gpio(pin)
+
+      # Output
+      if mode.to_s.match /output/
+        gpio.mode = PI_OUTPUT
+        
+        # Use pigpiod for setup, but still open line in libgpiod.
+        Denko::GPIOD.open_line_output(pin)
+
+      # Input
+      else
+        gpio.mode = PI_INPUT
+
+        # State change valid only if steady for this many microseconds.
+        # Only applies to callbacks hooked through pigpiod.
+        if glitch_time
+          gpio.glitch_filter(glitch_time)
+        end
+
+        # Pull down/up/none
+        if mode.to_s.match /pulldown/
+          gpio.pud = PI_PUD_DOWN
+        elsif mode.to_s.match /pullup/
+          gpio.pud = PI_PUD_UP
+        else
+          gpio.pud = PI_PUD_OFF
+        end
+        
+        # Use pigpiod for setup, but still open line in libgpiod.
+        Denko::GPIOD.open_line_input(pin)
+      end
+    end
+
+    # CMD = 1
+    def digital_write(pin, value)
+      pwm_clear(pin)
+      Denko::GPIOD.set_value(pin, value)
+    end
+    
+    # CMD = 2
+    def digital_read(pin)
+      unless @pwms[pin]
+        state = Denko::GPIOD.get_value(pin)
+        self.update(pin, state)
+        return state
+      end
+    end
+    
+    # CMD = 3
+    def pwm_write(pin, value)
+      # Disable servo if necessary.
+      pwm_clear(pin) if @pwms[pin] == :servo
+
+      unless @pwms[pin]
+        @pwms[pin] = get_gpio(pin).pwm
+        @pwms[pin].frequency = 1000
+      end
+      @pwms[pin].dutycycle = value
+    end
+
+    # PiGPIO native callbacks. Unused now.
+    def set_alert(pin, state=:off, options={})
+      # Listener on
+      if state == :on && !@pin_callbacks[pin]
+        callback = get_gpio(pin).callback(EITHER_EDGE) do |tick, level, pin_cb|
+          update(pin_cb, level, tick)
+        end
+        @pin_callbacks[pin] = callback
+
+      # Listener off
+      else
+        @pin_callbacks[pin].cancel if @pin_callbacks[pin]
+        @pin_callbacks[pin] = nil
+      end
+    end
+
+    # CMD = 6
+    def set_listener(pin, state=:off, options={})
+      # Listener on
+      if state == :on && !@pin_listeners.include?(pin)
+        add_listener(pin)
+      else
+        remove_listener(pin)
+      end
+    end
+
+    def digital_listen(pin, divider=4)
+      set_listener(pin, :on, {})
+    end
+
+    def stop_listener(pin)
+      set_listener(pin, :off)
+    end
+
+    def add_listener(pin)
+      @listen_mutex.synchronize do
+        @pin_listeners |= [pin]
+        @pin_listeners.sort!
+        @listen_states[pin] = Denko::GPIOD.get_value(pin)
+      end
+      start_listen_thread
+    end
+    
+    def remove_listener(pin)
+      @listen_mutex.synchronize do
+        @pin_listeners.delete(pin)
+        @listen_states[pin] = nil
+      end
+    end
+    
+    def start_listen_thread
+      return if @listen_thread
+      
+      @listen_thread = Thread.new do
+        #
+        # @listen_monitor_thread will adjust sleep time dyanmically,
+        # targeting even timing of 1 millisecond between loops.
+        #
+        @listen_count = 0
+        @listen_sleep = 0.001
+        start_time = Time.now
+
+        loop do
+          @listen_mutex.synchronize do
+            @pin_listeners.each do |pin|
+              @listen_reading = Denko::GPIOD.get_value(pin)
+              self.update(pin, @listen_reading) if (@listen_reading != @listen_states[pin])
+              @listen_states[pin] = @listen_reading
+            end
+          end
+          @listen_count += 1
+          sleep(@listen_sleep)
+        end
+      end
+
+      @listen_monitor_thread = Thread.new do
+        loop do
+          # Sample the listen rate over 5 seconds.
+          time1  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          count1 = @listen_count
+          sleep(5)
+          time2  = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          count2 = @listen_count
+          
+          # Quick maths.
+          loops = count2 - count1
+          time  = time2 - time1
+          active_time_per_loop = (time - (loops * @listen_sleep)) / loops
+
+          # Target 1 millisecond.
+          @listen_sleep = 0.001 - active_time_per_loop
+        end
+      end
+    end
+    
+    def stop_listen_thread
+      @listen_monitor_thread.kill
+      @listen_monitor_thread = nil
+      @listen_thread.kill
+      @listen_thread = nil
+    end
+  end
+end

data/lib/denko/piboard_i2c.rb

@@ -0,0 +1,119 @@
+module Denko
+  class PiBoard
+    # Maximum amount of bytes that can be read or written in a single I2C operation.
+    def i2c_limit
+      65535
+    end
+
+    def i2c_mutex
+      @i2c_mutex ||= Mutex.new
+    end
+
+    # CMD = 33
+    def i2c_search
+      i2c_mutex.synchronize do
+        found_string = ""
+
+        # Address ranges 0..7 and 120..127 are reserved.
+        # Try each address in 8..19 (0x08 to 0x77).
+        (0x08..0x77).each do |address|
+          i2c_open(1, address)
+          byte = Pigpio::IF.i2c_read_byte(pi_handle, i2c_handle)
+          # Add to the string colon separated if byte was valid.
+          found_string << "#{address}:" if byte >= 0
+          i2c_close
+        end
+
+        # Remove trailing colon.
+        found_string.chop! unless found_string.empty?
+
+        # Update the bus as if message came from microcontroller.
+        self.update(2, found_string)
+      end
+    end
+
+    # CMD = 34
+    def i2c_write(address, bytes, frequency=100000, repeated_start=false)
+      i2c_mutex.synchronize do
+        raise ArgumentError, "can't write more than #{i2c_limit} bytes to I2C" if bytes.length > i2c_limit
+
+        # Pack length as a 16-bit uint, then unpack it into 2 litle endian bytes.
+        length = [bytes.length].pack("S").unpack("C*")
+
+        # Prepend length to the bytes.
+        bytes = length + bytes
+
+        # Prepend write command and escape character (necessary for double byte write length).
+        bytes = [0x01, 0x07] + bytes
+        
+        # Enable and (re)disable repeated start as needed.
+        bytes = [0x02] + bytes + [0x03] if repeated_start
+
+        # Null terminate the command sequence.
+        bytes = bytes + [0x00]
+
+        # Send the command to the I2C1 interface, packed as uint8 string.
+        i2c_open(1, address)
+        Pigpio::IF.i2c_zip(pi_handle, i2c_handle, bytes.pack("C*"), 0)
+        i2c_close
+      end
+    end
+
+    # CMD = 35
+    def i2c_read(address, register, read_length, frequency=100000, repeated_start=false)
+      i2c_mutex.synchronize do
+        raise ArgumentError, "can't read more than #{i2c_limit} bytes to I2C" if read_length > i2c_limit
+        
+        # Start with number of bytes to read (16-bit number) represented as 2 little endian bytes.
+        buffer = [read_length].pack("S").unpack("C*")
+
+        # Prepend read command and escape character (necessary for double byte write length).
+        buffer = [0x01, 0x06] + buffer
+
+        # If a start register was given, write it first.
+        if register
+          register = [register].flatten
+          raise ArgumentError, "can't pre-write a register address > 4 bytes" if register.length > 4
+          buffer = [0x07, register.length] + register + buffer
+        end
+
+        # Enable and (re)disable repeated start as needed.
+        buffer = [0x02] + buffer + [0x03] if repeated_start
+
+        # Null terminate the command sequence.
+        buffer = buffer + [0x00]
+
+        # Send the command to the I2C1 interface, packed as uint8 string.
+        i2c_open(1, address)
+        read_bytes = Pigpio::IF.i2c_zip(pi_handle, i2c_handle, buffer.pack("C*"), read_length)
+        i2c_close
+
+        # Pigpio returned an error. Denko expects blank message after address.
+        if read_bytes.class == Integer
+          message = "#{address}-"
+        else
+          # Format the bytes like denko expects from a microcontroller.
+          message = read_bytes.split("").map { |byte| byte.ord.to_s }.join(",")
+          message = "#{address}-#{message}"
+        end
+        
+        # Call update with the message, as if it came from pin 2 (I2C1 SDA pin).
+        self.update(2, message)
+      end
+    end
+
+    private
+
+    attr_reader :i2c_handle
+
+    def i2c_open(bus_index, address)
+      @i2c_handle = Pigpio::IF.i2c_open(pi_handle, bus_index, address, 0)
+      raise StandardError, "I2C error, code #{@i2c_handle}" if @i2c_handle < 0
+    end
+
+    def i2c_close
+      Pigpio::IF.i2c_close(pi_handle, i2c_handle)
+      @i2c_handle = nil
+    end
+  end
+end

data/lib/denko/piboard_infrared.rb

@@ -0,0 +1,51 @@
+module Denko
+  class PiBoard
+    def infrared_emit(pin, frequency, pulses)
+      # 32-bit mask where only the bit corresponding to the GPIO in use is set.
+      pin_mask = 1 << pin
+      
+      # IR frequency given in kHz. Find half wave time in microseconds.
+      if @aarch64
+        # Compensate for pigpio doubling wave times on 64-bit systems.
+        half_wave_time = (250.0 / frequency)
+      else
+        # True half wave time.
+        half_wave_time = (500.0 / frequency)
+      end
+
+      # Standard wave setup.
+      new_wave
+      wave.tx_stop
+      wave.clear
+      wave.add_new
+            
+      # Build an array of pulses to add to the wave.
+      wave_pulses = []
+      pulses.each_with_index do |pulse, index|
+        # Even indices send the carrier wave.
+        if (index % 2 == 0)
+          cycles = (pulse / (half_wave_time * 2)).round
+          cycles.times do
+            wave_pulses << wave.pulse(pin_mask, 0x00, half_wave_time)
+            wave_pulses << wave.pulse(0x00, pin_mask, half_wave_time)
+          end
+          
+        # Odd indices are idle.
+        else
+          if @aarch64
+            # Half idle times for 64-bit systems.
+            wave_pulses << wave.pulse(0x00, pin_mask, pulse / 2)
+          else
+            wave_pulses << wave.pulse(0x00, pin_mask, pulse)
+          end
+        end
+      end      
+      wave.add_generic(wave_pulses)
+      wave_id = wave.create
+      
+      # Temporary workaround while Wave#send_once gets fixed.
+      Pigpio::IF.wave_send_once(@pi_handle, wave_id)
+      # wave.send_once(wave_id)
+    end
+  end
+end

data/lib/denko/piboard_map.rb

@@ -0,0 +1,49 @@
+module Denko
+  class PiBoard
+    MAP = {
+      # Only use SPI1 interface.
+      SS:   18,
+      MISO: 19,
+      MOSI: 20,
+      SCK:  21,
+      
+      # Only use I2C1 interface.
+      SDA: 2,
+      SCL: 3,
+
+      # Single UART
+      TX: 14,
+      RX: 15,
+    }
+
+    def map
+      MAP
+    end
+
+    def convert_pin(pin)
+      # Convert non numerical strings to symbols.
+      pin = pin.to_sym if (pin.class == String) && !(pin.match (/\A\d+\.*\d*/))
+
+      # Handle symbols.
+      if (pin.class == Symbol)
+        if map && map[pin]
+          return map[pin]
+        elsif map
+          raise ArgumentError, "error in pin: #{pin.inspect}. Make sure that pin is defined for this board by calling Board#map"
+        else
+          raise ArgumentError, "error in pin: #{pin.inspect}. Given a Symbol, but board has no map. Try using GPIO integer instead"
+        end
+      end
+
+      # Handle integers.
+      return pin if pin.class == Integer
+
+      # Try #to_i on anyting else. Will catch numerical strings.
+      begin
+        return pin.to_i
+      rescue
+        raise ArgumentError, "error in pin: #{pin.inspect}"
+      end
+    end
+  end
+end

data/lib/denko/piboard_pulse.rb

@@ -0,0 +1,82 @@
+require 'timeout'
+
+module Denko
+  class PiBoard    
+    def pulse_read(pin, reset: false, reset_time: 0, pulse_limit: 100, timeout: 200)
+      # Validation
+      raise ArgumentError, "error in reset: #{reset}. Should be either #{high} or #{low}"         if reset && ![high, low].include?(reset)
+      raise ArgumentError, "errror in reset_time: #{reset_time}. Should be 0..65535 microseconds" if (reset_time < 0) || (reset_time > 0xFFFF)
+      raise ArgumentError, "errror in pulse_limit: #{pulse_limit}. Should be 0..255 pulses"       if (pulse_limit < 0) || (pulse_limit > 0xFF)
+      raise ArgumentError, "errror in timeout: #{timeout}. Should be 0..65535 milliseconds"       if (timeout < 0) || (timeout > 0xFFFF)
+
+      if reset
+        # Reset pulse will be captured as the first 2 edges.
+        expected_edges = pulse_limit + 2 
+      else
+        # First edge is a starting reference, so store 1 extra.
+        expected_edges = pulse_limit + 1
+      end
+
+      # Storage for absolute tick time of each edge received from pigpio.
+      edges      = Array.new(expected_edges) {0}
+      edge_index = 0
+
+      # Switch to input mode immediately if no reset.
+      set_pin_mode(pin, :input) unless reset
+
+      # Add callback to catch edges.
+      callback = get_gpio(pin).callback(EITHER_EDGE) do |tick, level, pin_cb|
+        edges[edge_index] = tick
+        edge_index += 1
+        callback.cancel if edge_index == expected_edges
+      end
+
+      # If using reset pulse, do it, and the mode switch, while the callback is active.
+      if reset
+        set_pin_mode(pin, :output)
+        Denko::GPIOD.set_value(pin, reset)
+        sleep(reset_time / 1000000.0)
+
+        # Set pull to opposite direction of reset.
+        if (reset == low)
+          set_pin_mode(pin, :input_pullup)
+        else
+          set_pin_mode(pin, :input_pulldown)
+        end
+      end
+
+      # Wait for pulses or timeout.
+      begin
+        Timeout::timeout(timeout / 1000.0) do
+          loop do
+            edge_index == expected_edges ? break : sleep(0.001)
+          end
+        end
+      rescue Timeout::Error
+        # Allow less than pulse_limit to be read.
+      end
+      callback.cancel
+
+      # Ignore the first 2 edges (enable pulse) if reset used, 1 edge (starting reference) if not.
+      pulse_offset = reset ? 2 : 1
+      pulse_count  = edge_index - pulse_offset
+
+      # Handle no pulses read.
+      if pulse_count < 1
+        self.update(pin, "")
+        return nil
+      end
+      
+      # Convert from edge times to pulses.
+      i = 0
+      pulses = Array.new(pulse_count) {0}
+      while i < pulse_count
+        pulses[i] = edges[i+pulse_offset] - edges[i+pulse_offset-1]
+        i += 1
+      end
+
+      # Format pulses as if coming from a microcontroller, and update the component.
+      self.update(pin, pulses.join(","))
+    end
+  end
+end

data/lib/denko/piboard_servo.rb

@@ -0,0 +1,18 @@
+module Denko
+  class PiBoard
+    # CMD = 10
+    def servo_toggle(pin, value=:off, options={})
+      if value == :off
+        pwm_clear(pin)
+        digital_write(pin, 0)
+      else
+        @pwms[pin] = :servo
+      end
+    end
+    
+    # CMD = 11
+    def servo_write(pin, value=0)
+      Pigpio::IF.set_servo_pulsewidth(pi_handle, pin, value)
+    end
+  end
+end

data/lib/denko/piboard_spi.rb

@@ -0,0 +1,100 @@
+module Denko
+  class PiBoard
+
+    def spi_config(mode, bit_order)
+      # Config is a 32-bit mask, where bits 0 and 1 are a 2-bit number equal to the SPI mode.
+      # Default to SPI mode 0 when none given.
+      config = mode || 0
+      raise ArgumentError, "invalid SPI mode #{config}" unless (0..3).include? config
+
+      # Default to :msbfirst when bit_order not given.
+      bit_order ||= :msbfirst
+      unless (bit_order == :msbfirst) || (bit_order == :lsbfirst)
+        raise ArgumentError, "invalid bit order #{bitorder}"
+      end
+
+      # Bits 14 and 15 control MSBFIRST (0) or LSBFIRST (1) for MOSI and MISO respectively.
+      # Use same order for both directions like Arduino does.
+      config |= (0b11 << 14) if bit_order == :lsbfirst
+
+      # Use SPI1 interface instead of SPI0.
+      # Setting bit 8 means we're using SPI1.
+      config |= (0b1 << 8)
+
+      # Bits 5-7 set leaves all CE pins free, and allows any GPIO to be used for chip enable.
+      # We toggle separately in #spi_transfer.
+      config |= (0b111 << 5)
+
+      return config
+    end
+
+    # CMD = 26
+    def spi_transfer(select_pin, write: [], read: 0, frequency: nil, mode: nil, bit_order: nil)
+      # Default to 1MHz SPI frequency.
+      frequency ||= 1000000
+
+      # Make SPI config mask.
+      config = spi_config(mode, bit_order)
+
+      # Open SPI handle.
+      spi_open(frequency, config)
+      
+      # Chip enable low. select_pin == 255 means no chip enable (mostly for APA102 LEDs).
+      digital_write(select_pin, 0) unless select_pin == 255
+
+      # Do the SPI transfer.
+      write_bytes = write.pack("C*")
+      read_bytes = Pigpio::IF.spi_xfer(pi_handle, spi_handle, write_bytes)
+
+      # Close SPI handle.
+      spi_close
+
+      # Chip enable high. select_pin == 255 means no chip enable (mostly for APA102 LEDs).
+      digital_write(select_pin, 1) unless select_pin == 255
+
+      # Handle spi_xfer errors.
+      raise StandardError, "spi_xfer error, code #{read_bytes}" if read_bytes.class == Integer
+
+      # Handle read bytes.
+      if read > 0
+        message = ""
+
+        # Format like a microcontrolelr would. Limit to number of bytes requested.
+        i = 0
+        while i < read
+          message = "#{message},#{read_bytes[i].ord}"
+        end
+
+        # Call update with the message as if coming from select_pin.
+        self.update(select_pin, message)
+      end
+    end
+
+    # CMD = 27
+    def spi_listen
+    end
+
+    # CMD = 28
+    def spi_stop
+    end
+
+    private
+
+    attr_reader :spi_handle
+    
+    def spi_open(frequency, config)
+      # Give SPI channel as 0 (SPI CE0), even though we are toggling chip enable separately.
+      @spi_handle = Pigpio::IF.spi_open(pi_handle, 0, frequency, config)
+      raise StandardError, "SPI error, code #{@spi_handle}" if @spi_handle < 0
+    end
+
+    def spi_close
+      Pigpio::IF.spi_close(pi_handle, spi_handle)
+      @spi_handle  = nil
+    end
+
+    def spi_listeners
+      @spi_listeners ||= Array.new
+    end
+  end
+end

data/lib/denko/piboard_tone.rb

@@ -0,0 +1,39 @@
+module Denko
+  class PiBoard
+    # CMD = 17
+    def tone(pin, frequency, duration=nil)
+      # 32-bit mask where only the bit corresponding to the GPIO in use is set.
+      pin_mask = 1 << pin
+
+      if @aarch64
+        # pigpio doubles wave times on 64-bit systems for some reason. Halve it to compensate.
+        half_wave_time = (250000.0 / frequency).round
+      else
+        # This is the true halve wave time.
+        half_wave_time = (500000.0 / frequency).round
+      end
+
+      # Standard wave setup.
+      new_wave
+      wave.tx_stop
+      wave.clear
+      wave.add_new
+
+      # Build wave with a single cycle that will repeat.
+      wave.add_generic [
+        wave.pulse(pin_mask, 0x00, half_wave_time),
+        wave.pulse(0x00, pin_mask, half_wave_time)                  
+      ]
+      wave_id = wave.create
+
+      # Temporary workaround while Wave#send_repeat gets fixed.
+      Pigpio::IF.wave_send_repeat(@pi_handle, wave_id)
+      # wave.send_repeat(wave_id)
+    end
+
+    # CMD = 18
+    def no_tone(pin)
+      stop_wave
+    end
+  end
+end

data/lib/denko/piboard_version.rb

@@ -0,0 +1,5 @@
+module Denko
+  class PiBoard
+    VERSION = '0.13.0'
+  end
+end

data/lib/gpiod.rb

@@ -0,0 +1,6 @@
+require_relative 'gpiod/gpiod'
+
+module Denko
+  module GPIOD
+  end
+end

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification
+name: denko-piboard
+version: !ruby/object:Gem::Version
+  version: 0.13.0
+platform: ruby
+authors:
+- vickash
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2023-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pigpio
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+- !ruby/object:Gem::Dependency
+  name: denko
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.13'
+description: Denko::PiBoard is a drop-in replacement for Denko::Board. Use denko features
+  and component classes to be used directly on a Raspberry Pi.
+email: mail@vickash.com
+executables: []
+extensions:
+- ext/gpiod/extconf.rb
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- denko_piboard.gemspec
+- examples/pi_system_monitor.rb
+- ext/gpiod/extconf.rb
+- ext/gpiod/gpiod.c
+- lib/denko/piboard.rb
+- lib/denko/piboard_base.rb
+- lib/denko/piboard_core.rb
+- lib/denko/piboard_i2c.rb
+- lib/denko/piboard_infrared.rb
+- lib/denko/piboard_map.rb
+- lib/denko/piboard_pulse.rb
+- lib/denko/piboard_servo.rb
+- lib/denko/piboard_spi.rb
+- lib/denko/piboard_tone.rb
+- lib/denko/piboard_version.rb
+- lib/gpiod.rb
+homepage: https://github.com/denko-rb/denko-piboard
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/denko-rb/denko-piboard
+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.13
+signing_key:
+specification_version: 4
+summary: Use Raspberry Pi built-in GPIO as a Board class with the denko gem
+test_files: []