denko-piboard 0.13.2 → 0.14.0

data/lib/denko/piboard_i2c.rb

@@ -1,119 +1,96 @@
 module Denko
   class PiBoard
+    # Address ranges 0..7 and 120..127 are reserved.
+    # Try each address in 8..119 (0x08 to 0x77).
+    I2C_ADDRESS_RANGE = (0x08..0x77).to_a
+
     # 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
+    def i2c_search(index)
+      i2c_mutex(index).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
+        # I2C device may have reserved addresses. Exclude them.
+        addresses = I2C_ADDRESS_RANGE - map[:i2cs][index][:reserved_addresses].to_a
 
-        # Remove trailing colon.
-        found_string.chop! unless found_string.empty?
+        addresses.each do |address|
+          handle = i2c_open(index, address)
+          bytes = LGPIO.i2c_read_device(handle, 1)
+          found_string << "#{address}:" if bytes[0] > 0
+          i2c_close(handle)
+        end
 
-        # Update the bus as if message came from microcontroller.
-        self.update(2, found_string)
+        update_i2c(index, 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
+    def i2c_write(index, address, bytes, frequency=nil, repeated_start=false)
+      i2c_mutex(index).synchronize do
+        raise ArgumentError, "exceeded #{i2c_limit} bytes for #i2c_write" if bytes.length > i2c_limit
+
+        handle = i2c_open(index, address)
+        result = LGPIO.i2c_write_device(handle, bytes)
+        i2c_close(handle)
+        i2c_c_error("write", result, index, address) if result < 0
       end
     end
 
     # CMD = 35
-    def i2c_read(address, register, read_length, frequency=100000, repeated_start=false)
-      i2c_mutex.synchronize do
+    def i2c_read(index, address, register, read_length, frequency=nil, repeated_start=false)
+      i2c_mutex(index).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.
+        handle = i2c_open(index, address)
         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
+          result = LGPIO.i2c_write_device(handle, register)
+          i2c_c_error("read (register write)", result, index, address) if result < 0
         end
 
-        # Enable and (re)disable repeated start as needed.
-        buffer = [0x02] + buffer + [0x03] if repeated_start
+        bytes = LGPIO.i2c_read_device(handle, read_length)
+        i2c_close(handle)
+        i2c_c_error("read", bytes, index, address) if bytes.class == Integer
 
-        # 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)
+        # Prepend the address (0th element) to the data, and update the bus.
+        bytes.unshift(address)
+        update_i2c(index, bytes)
       end
     end
 
     private
 
-    attr_reader :i2c_handle
+    def i2c_mutex(index)
+      i2c_mutexes[index] ||= Mutex.new
+    end
+
+    def i2c_mutexes
+      @i2c_mutexes ||= []
+    end
+
+    def i2c_open(index, address, flags=0x00)
+      handle = LGPIO.i2c_open(index, address, flags)
+      i2c_c_error("open", handle, index, address) if handle < 0
+      handle
+    end
+
+    def i2c_close(handle)
+      result = LGPIO.i2c_close(handle)
+      if result < 0
+        raise StandardError, "lgpio C I2C close error: #{result} for handle #{handle}"
+      end
+    end
 
-    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
+    def i2c_c_error(name, error, index, address)
+      raise StandardError, "lgpio C I2C #{name} error: #{error} for /dev/i2c-#{index} with address 0x#{address.to_s(16)}"
     end
 
-    def i2c_close
-      Pigpio::IF.i2c_close(pi_handle, i2c_handle)
-      @i2c_handle = nil
+    def update_i2c(index, data)
+      dev = hw_i2c_comps[index]
+      dev.update(data) if dev
     end
   end
 end

data/lib/denko/piboard_i2c_bb.rb

@@ -0,0 +1,48 @@
+module Denko
+  class PiBoard
+    def i2c_bbs
+      @i2c_bbs ||= []
+    end
+
+    def i2c_bb_interface(scl, sda)
+      # Convert the pins into a config array to check.
+      ch, cl = gpio_tuple(scl)
+      dh, dl = gpio_tuple(sda)
+      config = [ch, cl, dh, dl]
+
+      # Check if any already exists with that array and return it.
+      i2c_bbs.each { |bb| return bb if (config == bb.config) }
+
+      # If not, create one.
+      hash =  { scl:  { handle: ch, line: cl },
+                sda:  { handle: dh, line: dl } }
+
+      i2c_bb = LGPIO::I2CBitBang.new(hash)
+      i2c_bbs << i2c_bb
+      i2c_bb
+    end
+
+    def i2c_bb_search(scl, sda)
+      interface    = i2c_bb_interface(scl, sda)
+      devices      = interface.search
+      found_string = ""
+      found_string = devices.join(":") if devices
+      self.update(sda, found_string)
+    end
+
+    def i2c_bb_write(scl, sda, address, bytes, repeated_start=false)
+      interface = i2c_bb_interface(scl, sda)
+      interface.write(address, bytes)
+    end
+
+    def i2c_bb_read(scl, sda, address, register, read_length, repeated_start=false)
+      interface = i2c_bb_interface(scl, sda)
+      interface.write(address, register) if register
+      bytes = interface.read(address, read_length)
+
+      # Prepend the address (0th element) to the data, and update the SDA pin.
+      bytes.unshift(address)
+      self.update(sda, bytes)
+    end
+  end
+end

data/lib/denko/piboard_infrared.rb

@@ -1,51 +1,14 @@
 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
+      # Main gem uses frequency in kHz. Set it in Hz.
+      pwm = hardware_pwm_from_pin(pin, frequency: frequency*1000)
 
-      # 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)
+      # The actual strings for the sysfs PWM interface.
+      duty_path = "#{pwm.path}duty_cycle"
+      duty_ns   = (0.333333 * pwm.period).round.to_s
+
+      pwm.tx_wave_ook(duty_path, duty_ns, pulses)
     end
   end
 end

data/lib/denko/piboard_led_array.rb

@@ -0,0 +1,9 @@
+module Denko
+  class PiBoard
+    def show_ws2812(pin, pixel_buffer, spi_index:)
+      handle = spi_open(spi_index, 2_400_000, 0)
+      LGPIO.spi_ws2812_write(handle, pixel_buffer)
+      spi_close(handle)
+    end
+  end
+end

data/lib/denko/piboard_map.rb

@@ -1,49 +1,132 @@
+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
   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_servo.rb

@@ -2,17 +2,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
+      pwm = hardware_pwm_from_pin(pin)
+      if (value == :off)
+        pwm.duty_cycle = 0
+        pwm.disable
+      elsif
+        pwm.frequency = 50
       end
     end
-    
+
     # CMD = 11
     def servo_write(pin, value=0)
-      Pigpio::IF.set_servo_pulsewidth(pi_handle, pin, value)
+      hardware_pwms[pin].duty_us = value
     end
   end
 end