denko-piboard 0.13.2 → 0.15.0

data/lib/denko/piboard_map.rb

@@ -1,49 +1,136 @@
+require 'yaml'
+
 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
+    DEFAULT_MAP_FILE = ".denko_piboard_map.yml"
 
-    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"
+    attr_reader :map, :alert_lut, :gpiochip_lookup_optimized
+
+    def parse_map(map_yaml)
+      @map = YAML.load_file(map_yaml, symbolize_names: true)
+
+      # Validate GPIO chip and line numbers for pins. Also build a lookup table for alerts.
+      @alert_lut = []
+      map[:pins].each_pair do |k, h|
+        raise StandardError, "invalid pin number: #{k} in YAML map :pins. Should be Integer"  unless k.class == Integer
+        raise StandardError, "invalid GPIO chip for GPIO #{k[:chip]}. Should be Integer"      unless h[:chip].class == Integer
+        raise StandardError, "invalid GPIO chip for GPIO #{k[:line]}. Should be Integer"      unless h[:line].class == Integer
+        @alert_lut[h[:chip]] ||= []
+        @alert_lut[h[:chip]][h[:line]] = k
+      end
+
+      # Validate PWMs
+      map[:pwms].each_pair do |k, h|
+        raise StandardError, "invalid pin number: #{k} in YAML map :pwms. Should be Integer"    unless k.class == Integer
+        raise StandardError, "invalid pwmchip: #{h[:pwmchip]}} for pin #{k}. Should be Integer" unless h[:pwmchip].class == Integer
+        raise StandardError, "invalid channel: #{h[:channel]}} for pin #{k}. Should be Integer" unless h[:channel].class == Integer
+
+        dev_path = "/sys/class/pwm/pwmchip#{h[:pwmchip]}/pwm#{h[:channel]}"
+        raise StandardError, "board map error. Pin #{k} appears to be bound to both #{dev_path} and #{bound_pins[k]}" if bound_pins[k]
+        bound_pins[k] = dev_path
+      end
+
+      # Validate I2Cs
+      map[:i2cs].each_pair do |k, h|
+        raise StandardError, "invalid I2C index: #{k} in YAML map :i2cs. Should be Integer" unless k.class == Integer
+        dev_path = "/dev/i2c-#{k}"
+
+        [:scl, :sda].each do |pin_sym|
+          pin = h[pin_sym]
+          raise StandardError, "missing #{pin_sym}: for I2C#{k}" unless pin
+          raise StandardError, "invalid #{pin_sym}: #{pin} for I2C#{k}. Should be Integer" unless pin.class == Integer
+          raise StandardError, "board map error. Pin #{pin} appears to be bound to both #{dev_path} and #{bound_pins[pin]}" if bound_pins[pin]
+          bound_pins[pin] = dev_path
+        end
+      end
+
+      # Validate SPIs
+      map[:spis].each_pair do |k, h|
+        raise StandardError, "invalid SPI index: #{k} in YAML map :spis. Should be Integer" unless k.class == Integer
+        dev_path = "dev/spidev#{k}.0"
+
+        [:clk, :mosi, :miso, :cs0].each do |pin_sym|
+          pin = h[pin_sym]
+          raise StandardError, "missing #{pin_sym}: for SPI#{k}" if (pin_sym == :clk) && !pin
+          next unless pin
+
+          raise StandardError, "invalid #{pin_sym}: #{pin} for SPI#{k}. Should be Integer" unless pin.class == Integer
+          raise StandardError, "board map error. Pin #{pin} appears to be bound to both #{dev_path} and #{bound_pins[pin]}" if bound_pins[pin]
+          bound_pins[pin] = dev_path
         end
       end
 
-      # Handle integers.
-      return pin if pin.class == Integer
+      load_gpiochip_lookup_optimizations
+    end
+
+    #
+    # Monkey patch to eliminate lookups, and improve performance,
+    # when all GPIO lines are on a single gpiochip, and the readable
+    # GPIO numbers exactly match the GPIO line numbers.
+    #
+    def load_gpiochip_lookup_optimizations
+      @gpiochip_lookup_optimized = false
+
+      # Makes performance slightly worse on YJIT?
+      return if defined?(RubyVM::YJIT) && RubyVM::YJIT.enabled?
+
+      # All pins must be defined on the same gpiochip.
+      unique_gpiochips = map[:pins].each_value.map { |pin_def| pin_def[:chip] }.uniq
+      return if unique_gpiochips.length != 1
 
-      # Try #to_i on anyting else. Will catch numerical strings.
-      begin
-        return pin.to_i
-      rescue
-        raise ArgumentError, "error in pin: #{pin.inspect}"
+      # For each pin, the key integer must be equal to the line integer.
+      map[:pins].each_pair do |gpio_num, pin_def|
+        return unless (gpio_num == pin_def[:line])
       end
+
+      # Open the handle so it can be given as a literal in the optimized methods.
+      gpiochip_single_handle = gpio_handle(unique_gpiochips.first)
+
+      code = File.read(File.dirname(__FILE__) + "/piboard_core_optimize_lookup.rb")
+      code = code.gsub("__GPIOCHIP_SINGLE_HANDLE__", gpiochip_single_handle.to_s)
+
+      singleton_class.class_eval(code)
+      @gpiochip_lookup_optimized = true
+    end
+
+    # Make a new tuple, given a human-readable pin number, using values from the map.
+    def gpio_tuple(index)
+      return gpio_tuples[index] if gpio_tuples[index]
+
+      raise ArgumentError, "pin #{index} does not exist or not included in map" unless map[:pins][index]
+      raise ArgumentError, "pin #{index} cannot be used as GPIO. Bound to #{bound_pins[index]}" if bound_pins[index]
+
+      handle = gpio_handle(map[:pins][index][:chip])
+      line = map[:pins][index][:line]
+
+      gpio_tuples[index] = [handle, line]
+    end
+
+    # Cache tuples of [handle, line_number], keyed to human-readable pin numbers.
+    def gpio_tuples
+      @gpio_tuples ||= []
+    end
+
+    # Store multiple LGPIO handles, since one board might have multiple chips.
+    def gpio_handle(index)
+      gpio_handles[index] ||= LGPIO.chip_open(index)
+    end
+
+    def gpio_handles
+      @gpio_handles ||= []
+    end
+
+    # Keep track of pins bound by non-GPIO peripherals.
+    def bound_pins
+      @bound_pins ||= []
+    end
+
+    def convert_pin(pin)
+      pin.to_i if pin
+    end
+    
+    def pin_is_pwm?(pin)
+      map[:pwms][pin]
     end
   end
 end

data/lib/denko/piboard_one_wire.rb

@@ -0,0 +1,42 @@
+module Denko
+  class PiBoard
+    def one_wires
+      @one_wires ||= []
+    end
+
+    def one_wire_interface(pin)
+      handle, gpio  = gpio_tuple(pin)
+
+      # Check if any already exists with that array and return it.
+      one_wires.each { |bb| return bb if (handle == bb.handle && gpio == bb.gpio) }
+
+      # If not, create one.
+      one_wire = LGPIO::OneWire.new(handle, gpio)
+      one_wires << one_wire
+      one_wire
+    end
+
+    def one_wire_reset(gpio, check_presence=0)
+      interface = one_wire_interface(gpio)
+      presence  = interface.reset ? 0 : 1
+      self.update(gpio, [presence]) if check_presence != 0
+    end
+
+    def one_wire_search(gpio, branch_mask)
+      interface    = one_wire_interface(gpio)
+      result_array = interface.search_pass(branch_mask)
+      self.update(gpio, result_array)
+    end
+
+    def one_wire_write(gpio, parasite, *data)
+      interface = one_wire_interface(gpio)
+      interface.write(data.flatten, parasite: parasite)
+    end
+
+    def one_wire_read(gpio, length)
+      interface    = one_wire_interface(gpio)
+      result_array = interface.read(length)
+      self.update(gpio, result_array)
+    end
+  end
+end

data/lib/denko/piboard_pulse.rb

@@ -1,7 +1,12 @@
 require 'timeout'
 
 module Denko
-  class PiBoard    
+  class PiBoard
+    def hcsr04_read(echo_pin, trigger_pin)
+      microseconds = LGPIO.gpio_read_ultrasonic(@gpio_handle, trigger_pin, echo_pin, 10)
+      self.update(echo_pin, microseconds.to_s)
+    end
+
     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)
@@ -9,74 +14,12 @@ module Denko
       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
+      pulses = LGPIO.gpio_read_pulses_us(@gpio_handle, pin, reset_time, reset, pulse_limit, timeout)
+      if pulses.class == Array
+        self.update(pin, pulses.join(","))
+      elsif pulse.class == Integer
+        raise "could not read pulses from GPIO #{pin}. LGPIO error: #{pulses}"
       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_spi.rb

@@ -1,100 +1,74 @@
 module Denko
   class PiBoard
+    def spi_limit
+      4096
+    end
 
-    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)
+    def spi_flags(mode)
+      mode ||= 0
+      raise ArgumentError, "invalid SPI mode #{mode}" unless (0..3).include? mode
 
-      # 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.15.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"