denko-piboard 0.13.2 → 0.14.0

data/lib/denko/piboard_spi.rb

@@ -1,100 +1,70 @@
 module Denko
   class PiBoard
+    def spi_flags(mode)
+      mode ||= 0
+      raise ArgumentError, "invalid SPI mode #{mode}" unless (0..3).include? mode
 
-    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)
+      # Flags is a 32-bit mask. Bits [1..0] are the SPI mode. Default to 0.
+      config = mode
 
       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)
+    def spi_transfer(index, select, write:[], read:0, frequency: 1_000_000, mode: 0, bit_order: nil)
+      # Default frequency. Flags just has mode.
+      frequency ||= 1_000_000
+      flags       = spi_flags(mode)
+      handle      = spi_open(index, frequency, flags)
 
-      # 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
+      # Handle select_pin unless it's same as CS0 for this interface.
+      digital_write(select, 0) if select && (select != map[:spis][index][:cs0])
+      bytes = LGPIO.spi_xfer(handle, write, read)
+      spi_close(handle)
+      digital_write(select, 1) if select && (select != map[:spis][index][:cs0])
 
-      # Do the SPI transfer.
-      write_bytes = write.pack("C*")
-      read_bytes = Pigpio::IF.spi_xfer(pi_handle, spi_handle, write_bytes)
+      spi_c_error("xfer", bytes, index) if bytes.class == Integer
 
-      # 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
+      # Update component attached to select pin with read bytes.
+      self.update(select, bytes) if (read > 0 && select)
+    end
 
-        # Call update with the message as if coming from select_pin.
-        self.update(select_pin, message)
-      end
+    def spi_listen(*arg, **kwargs)
+      raise NotImplementedError, "PiBoard#spi_listen not implemented yet"
     end
 
-    # CMD = 27
-    def spi_listen
+    def spi_stop(pin)
     end
 
-    # CMD = 28
-    def spi_stop
+    def spi_listeners
+      @spi_listeners ||= Array.new
     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
+    def spi_mutex(index)
+      spi_mutexes[index] ||= Mutex.new
     end
 
-    def spi_close
-      Pigpio::IF.spi_close(pi_handle, spi_handle)
-      @spi_handle  = nil
+    def spi_mutexes
+      @spi_mutexes ||= []
     end
 
-    def spi_listeners
-      @spi_listeners ||= Array.new
+    def spi_open(index, frequency, flags=0x00)
+      # Always use 0 (SPI CS0) for channel. We are toggling chip enable separately.
+      handle = LGPIO.spi_open(index, 0, frequency, flags)
+      spi_c_error("open", handle, index) if handle < 0
+      handle
+    end
+
+    def spi_close(handle)
+      result = LGPIO.spi_close(handle)
+      if result < 0
+        raise StandardError, "lgpio C SPI close error: #{result} for handle #{handle}"
+      end
+    end
+
+    def spi_c_error(name, error, index)
+      raise StandardError, "lgpio C SPI #{name} error: #{error} for /dev/spidev#{index}"
     end
   end
 end

data/lib/denko/piboard_spi_bb.rb

@@ -0,0 +1,41 @@
+module Denko
+  class PiBoard
+    attr_reader :spi_bbs
+
+    def spi_bbs
+      @spi_bbs ||= []
+    end
+
+    def spi_bb_interface(clock, input, output)
+      # Convert the pins into a config array to check.
+      ch, cl = gpio_tuple(clock)
+      ih, il = input  ? gpio_tuple(input)  : [nil, nil]
+      oh, ol = output ? gpio_tuple(output) : [nil, nil]
+      config = [ch, cl, ih, il, oh, ol]
+
+      # Check if any already exists with that array and return it.
+      spi_bbs.each { |bb| return bb if (config == bb.config) }
+
+      # If not, create one.
+      hash =  { clock:  { handle: ch, line: cl },
+                input:  { handle: ih, line: il },
+                output: { handle: oh, line: ol } }
+
+      spi_bb = LGPIO::SPIBitBang.new(hash)
+      spi_bbs << spi_bb
+      spi_bb
+    end
+
+    def spi_bb_transfer(select, clock:, input: nil, output: nil, write: [], read: 0, frequency: nil, mode: nil, bit_order: nil)
+      interface = spi_bb_interface(clock, input, output)
+      select_hash = select ? { handle: gpio_tuple(select)[0], line: gpio_tuple(select)[0] } : nil
+
+      bytes = interface.transfer(write: write, read: read, select: select_hash, order: bit_order, mode: mode)
+      self.update(select, bytes) if (read > 0 && select)
+    end
+
+    def spi_bb_listen(*arg, **kwargs)
+      raise NotImplementedError, "PiBoard#spi_bb_listen not implemented yet"
+    end
+  end
+end

data/lib/denko/piboard_tone.rb

@@ -2,38 +2,27 @@ 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
+      if @hardware_pwms[pin]
+        @hardware_pwms[pin].frequency    = frequency
+        @hardware_pwms[pin].duty_percent = 33
+        sleep duration if duration
       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
+        raise ArgumentError, "maximum software PWM frequency is 10 kHz" if frequency > 10_000
+        cycles = 0
+        cycles = (frequency * duration).round if duration
 
-      # Temporary workaround while Wave#send_repeat gets fixed.
-      Pigpio::IF.wave_send_repeat(@pi_handle, wave_id)
-      # wave.send_repeat(wave_id)
+        sleep 0.05 while (LGPIO.tx_room(@gpio_handle, pin, LGPIO::TX_PWM) == 0)
+        LGPIO.tx_pwm(@gpio_handle, pin, frequency, 33, 0, cycles)
+      end
     end
 
     # CMD = 18
     def no_tone(pin)
-      stop_wave
+      digital_write(pin, HIGH)
+    end
+
+    def tone_busy(pin)
+      LGPIO.tx_busy(@gpio_handle, pin, LGPIO::TX_PWM)
     end
   end
 end

data/lib/denko/piboard_version.rb

@@ -1,5 +1,5 @@
 module Denko
   class PiBoard
-    VERSION = '0.13.2'
+    VERSION = '0.14.0'
   end
 end

data/scripts/99-denko.rules

@@ -0,0 +1,9 @@
+#
+# A system ruby must be installed at /usr/bin/ruby
+# Change path/to/set_permissions.rb to the full path where you saved the permissions script
+# Ensure the USERNAME constant, in that copy of the script, is set to your Linux username as a string literal.
+#
+SUBSYSTEM=="gpio*",   ACTION=="add", PROGRAM="/usr/bin/ruby /path/to/set_permissions.rb gpio"
+SUBSYSTEM=="i2c*",    ACTION=="add", PROGRAM="/usr/bin/ruby /path/to/set_permissions.rb i2c"
+SUBSYSTEM=="spidev*", ACTION=="add", PROGRAM="/usr/bin/ruby /path/to/set_permissions.rb spi"
+SUBSYSTEM=="pwm*",    ACTION=="add", PROGRAM="/usr/bin/ruby /path/to/set_permissions.rb pwm"

data/scripts/set_permissions.rb

@@ -0,0 +1,131 @@
+require 'yaml'
+
+# `whoami` returns the name of the user running this script.
+#
+# If you automate this to run on startup (as root), you must put
+# your literal Linux username here instead. If not, it will attempt
+# to load a map from root's home, and root will get permissions, not you.
+#
+USERNAME = `whoami`.strip
+
+GPIO_GROUP_NAME = "gpio"
+I2C_GROUP_NAME = "i2c"
+SPI_GROUP_NAME = "spi"
+PWM_GROUP_NAME = "pwm"
+
+MAP_FILENAME = ".denko_piboard_map.yml"
+$added_to_group = false
+
+# Create groups and add the user to them as needed.
+def group_setup(group_name)
+  group_line = `egrep -i "^#{group_name}" /etc/group`
+
+  if group_line.empty?
+    `sudo groupadd #{group_name}`
+  end
+
+  unless group_line.match(/#{USERNAME}/)
+    `sudo usermod -aG #{group_name} #{USERNAME}`
+    puts "Added user #{USERNAME} to group #{group_name}. "
+    $added_to_group = true
+  else
+    puts "User #{USERNAME} already in group #{group_name}. "
+  end
+end
+
+# Change gpiochip ownership and permissions.
+def setup_gpio
+  gpiochips = $map["pins"].each_value.map { |pin_def| pin_def["chip"] }.uniq
+  group_setup(GPIO_GROUP_NAME) unless gpiochips.empty?
+  gpiochips.each do |chip_index|
+    `sudo chgrp #{GPIO_GROUP_NAME} /dev/gpiochip#{chip_index}*`
+    `sudo chmod g+rw /dev/gpiochip#{chip_index}*`
+    puts "Set permissions for /dev/gpiochip#{chip_index}"
+  end
+end
+
+# Change I2C ownership and permissions
+def setup_i2c
+  i2cs = $map["i2cs"].keys
+  group_setup(I2C_GROUP_NAME) unless i2cs.empty?
+  i2cs.each do |i2c_index|
+    dev = "/dev/i2c-#{i2c_index}"
+    `sudo chgrp #{I2C_GROUP_NAME} #{dev}`
+    `sudo chmod g+rw #{dev}`
+    puts "Set permissions for #{dev}"
+  end
+end
+
+# Change SPI ownership and permissions
+def setup_spi
+  spis = $map["spis"].keys
+  group_setup(SPI_GROUP_NAME) unless spis.empty?
+  spis.each do |spi_index|
+    dev = "/dev/spidev#{spi_index}"
+    `sudo chgrp #{SPI_GROUP_NAME} #{dev}*`
+    `sudo chmod g+rw #{dev}*`
+    puts "Set permissions for #{dev}.*"
+  end
+end
+
+def setup_pwm
+# Change PWM ownership and permissions
+  pwms = $map["pwms"]
+  unless pwms.empty?
+    group_setup(PWM_GROUP_NAME)
+    print "Exported and set permissions for: /sys/class/pwm/{"
+  end
+
+  i = 0
+  pwms.each_value do |hash|
+    i += 1
+    chip = hash["pwmchip"]
+    chan = hash["channel"]
+    chip_dir = "/sys/class/pwm/pwmchip#{chip}"
+    channel_dir = "/sys/class/pwm/pwmchip#{chip}/pwm#{chan}"
+
+    # Chip dir permissions
+    `sudo chgrp -RH #{PWM_GROUP_NAME} #{chip_dir}`
+    `sudo chmod -R g+rw #{chip_dir}`
+
+    # Export
+    `sudo echo #{chan} > #{chip_dir}/export` unless Dir.exist?(channel_dir)
+
+    # Channel dir permissions
+    `sudo chgrp -RH #{PWM_GROUP_NAME} #{channel_dir}`
+    `sudo chmod -R g+rw #{channel_dir}`
+
+    print channel_dir.gsub("/sys/class/pwm/", "")
+    print ", " unless i == pwms.length
+  end
+  puts "}"
+end
+
+# Load map
+home = Dir.home(USERNAME)
+yaml_path = home +"/#{MAP_FILENAME}"
+$map = YAML.load_file(yaml_path)
+puts
+
+case ARGV[0]
+when "gpio"
+  setup_gpio
+when "i2c"
+  setup_i2c
+when "spi"
+  setup_spi
+when "pwm"
+  setup_pwm
+else
+  setup_gpio
+  setup_i2c
+  setup_spi
+  setup_pwm
+end
+
+# Notify user
+if $added_to_group
+  puts
+  puts "User #{USERNAME} has been added to new group(s). Log out, then log back in for this to take effect."
+end
+puts

metadata

@@ -1,70 +1,98 @@
 --- !ruby/object:Gem::Specification
 name: denko-piboard
 version: !ruby/object:Gem::Version
-  version: 0.13.2
+  version: 0.14.0
 platform: ruby
 authors:
 - vickash
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-09-27 00:00:00.000000000 Z
+date: 2024-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: pigpio
+  name: lgpio
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.12
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.12
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: denko
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '0.13'
+        version: '0.14'
   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.
+        version: '0.14'
+description: Use Linux single-board-computer GPIO, I2C, SPI and PWM in Ruby
 email: mail@vickash.com
 executables: []
-extensions:
-- ext/gpiod/extconf.rb
+extensions: []
 extra_rdoc_files: []
 files:
 - LICENSE
 - README.md
 - Rakefile
+- board_maps/README.md
+- board_maps/orange_pi_zero_2w.yml
+- board_maps/radxa_zero3.yml
+- board_maps/raspberry_pi.yml
 - denko_piboard.gemspec
+- examples/digital_io/bench_out.rb
+- examples/digital_io/rotary_encoder.rb
+- examples/display/ssd1306.rb
+- examples/i2c/bitbang_aht10.rb
+- examples/i2c/bitbang_search.rb
+- examples/i2c/bitbang_ssd1306_bench.rb
+- examples/i2c/search.rb
+- examples/led/blink.rb
+- examples/led/fade.rb
+- examples/led/ws2812_bounce.rb
+- examples/motor/servo.rb
 - examples/pi_system_monitor.rb
-- ext/gpiod/extconf.rb
-- ext/gpiod/gpiod.c
+- examples/pulse_io/buzzer.rb
+- examples/pulse_io/infrared.rb
+- examples/sensor/aht10.rb
+- examples/sensor/dht.rb
+- examples/sensor/ds18b20.rb
+- examples/sensor/hcsr04.rb
+- examples/sensor/neat_tph_readings.rb
+- examples/spi/bb_loopback.rb
+- examples/spi/loopback.rb
+- examples/spi/output_register.rb
 - lib/denko/piboard.rb
 - lib/denko/piboard_base.rb
 - lib/denko/piboard_core.rb
+- lib/denko/piboard_core_optimize_lookup.rb
+- lib/denko/piboard_hardware_pwm.rb
 - lib/denko/piboard_i2c.rb
+- lib/denko/piboard_i2c_bb.rb
 - lib/denko/piboard_infrared.rb
+- lib/denko/piboard_led_array.rb
 - lib/denko/piboard_map.rb
+- lib/denko/piboard_one_wire.rb
 - lib/denko/piboard_pulse.rb
 - lib/denko/piboard_servo.rb
 - lib/denko/piboard_spi.rb
+- lib/denko/piboard_spi_bb.rb
 - lib/denko/piboard_tone.rb
 - lib/denko/piboard_version.rb
-- lib/gpiod.rb
+- scripts/99-denko.rules
+- scripts/set_permissions.rb
 homepage: https://github.com/denko-rb/denko-piboard
 licenses:
 - MIT
@@ -78,15 +106,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: '3'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.4.13
+rubygems_version: 3.5.20
 signing_key:
 specification_version: 4
-summary: Use Raspberry Pi built-in GPIO as a Board class with the denko gem
+summary: Linux SBC GPIO in Ruby
 test_files: []

data/ext/gpiod/extconf.rb

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