denko-piboard 0.13.2 → 0.15.0

data/lib/denko/piboard_core.rb

@@ -1,94 +1,122 @@
 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
+    REPORT_SLEEP_TIME = 0.001
+    INPUT_MODES  = [:input, :input_pullup, :input_pulldown]
+    OUTPUT_MODES = [:output, :output_pwm, :output_open_drain, :output_open_source]
+    PIN_MODES = INPUT_MODES + OUTPUT_MODES
+
+    def set_pin_mode(pin, mode=:input, options={})
+      # Is the mode valid?
+      unless PIN_MODES.include?(mode)
+        raise ArgumentError, "cannot set mode: #{mode}. Should be one of: #{PIN_MODES.inspect}"
+      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
+      # If pin is bound to hardware PWM, allow it to be used as :output_pwm. OR :output.
+      if map[:pwms][pin]
+        if (mode == :output_pwm)
+          return hardware_pwm_from_pin(pin, options)
+        elsif (mode == :output)
+          puts "WARNING: using hardware PWM on pin #{pin} as GPIO. Will be slower than regular GPIO."
+          return hardware_pwm_from_pin(pin, options)
         else
-          gpio.pud = PI_PUD_OFF
+          raise "Pin #{pin} is bound to hardware PWM. It can only be used as :output or :output_pwm"
         end
-        
-        # Use pigpiod for setup, but still open line in libgpiod.
-        Denko::GPIOD.open_line_input(pin)
       end
+
+      # Attempt to free the pin.
+      LGPIO.gpio_free(*gpio_tuple(pin))
+
+      # Try to claim the GPIO.
+      if OUTPUT_MODES.include?(mode)
+        flags  = LGPIO::SET_PULL_NONE
+        flags  = LGPIO::SET_OPEN_DRAIN  if mode == :output_open_drain
+        flags  = LGPIO::SET_OPEN_SOURCE if mode == :output_open_source
+        result = LGPIO.gpio_claim_output(*gpio_tuple(pin), flags, LOW)
+      else
+        flags  = LGPIO::SET_PULL_NONE
+        flags  = LGPIO::SET_PULL_UP   if mode == :input_pullup
+        flags  = LGPIO::SET_PULL_DOWN if mode == :input_pulldown
+        result = LGPIO.gpio_claim_input(*gpio_tuple(pin), flags)
+      end
+      raise "could not claim GPIO for pin #{pin}. lgpio C error: #{result}" if result < 0
+
+      pin_configs[pin] = pin_configs[pin].to_h.merge(mode: mode).merge(options)
+    end
+
+    def set_pin_debounce(pin, debounce_time)
+      return unless debounce_time
+      result = LGPIO.gpio_set_debounce(*gpio_tuple(pin), debounce_time)
+      raise "could not set debounce for pin #{pin}. lgpio C error: #{result}" if result < 0
+
+      pin_configs[pin] = pin_configs[pin].to_h.merge(debounce_time: debounce_time)
     end
 
-    # CMD = 1
     def digital_write(pin, value)
-      pwm_clear(pin)
-      Denko::GPIOD.set_value(pin, value)
+      if hardware_pwms[pin]
+        hardware_pwms[pin].duty_percent = (value == 0) ? 0 : 100
+      else
+        handle, line = gpio_tuple(pin)
+        LGPIO.gpio_write(handle, line, value)
+      end
     end
-    
-    # CMD = 2
+
     def digital_read(pin)
-      unless @pwms[pin]
-        state = Denko::GPIOD.get_value(pin)
-        self.update(pin, state)
-        return state
+      if hardware_pwms[pin]
+        state = hardware_pwms[pin].duty_percent
+      else
+        handle, line = gpio_tuple(pin)
+        state = LGPIO.gpio_read(handle, line)
       end
+      self.update(pin, state)
+      return state
     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
+    def pwm_write(pin, duty)
+      if hardware_pwms[pin]
+        hardware_pwms[pin].duty = duty
+      else
+        handle, line = gpio_tuple(pin)
+        frequency    = pin_configs[pin][:frequency] || 1000
+        period       = pin_configs[pin][:period]    || 1_000_000
+        duty_percent = (duty.to_f / period) * 100
+        LGPIO.tx_pwm(handle, line, frequency, duty_percent, 0, 0)
       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
+    def dac_write(pin, value)
+      raise NotImplementedError, "PiBoard#dac_write not implemented"
+    end
 
-      # Listener off
-      else
-        @pin_callbacks[pin].cancel if @pin_callbacks[pin]
-        @pin_callbacks[pin] = nil
-      end
+    def analog_read(pin, negative_pin=nil, gain=nil, sample_rate=nil)
+      raise NotImplementedError, "PiBoard#analog_read not implemented"
     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)
+      # Validate listener is digital only.
+      options[:mode] ||= :digital
+      unless options[:mode] == :digital
+        raise ArgumentError, "error in mode: #{options[:mode]}. Should be one of: [:digital]"
+      end
+
+      # Validate state.
+      unless (state == :on) || (state == :off)
+        raise ArgumentError, "error in state: #{options[:state]}. Should be one of: [:on, :off]"
+      end
+
+      # Only way to stop getting alerts is to free the GPIO.
+      LGPIO.gpio_free(*gpio_tuple(pin))
+
+      # Reclaim it as input if needed.
+      config   = pin_configs[pin]
+      config ||= { mode: :input, debounce_time: nil } if state == :on
+      if config
+        set_pin_mode(pin, config[:mode])
+        set_pin_debounce(pin, config[:debounce_time])
+      end
+
+      if state == :on
+        LGPIO.gpio_claim_alert(*gpio_tuple(pin), 0, LGPIO::BOTH_EDGES)
+        start_alert_thread unless @alert_thread
       end
     end
 
@@ -96,77 +124,69 @@ module Denko
       set_listener(pin, :on, {})
     end
 
+    def analog_listen(pin, divider=16)
+      raise NotImplementedError, "PiBoard#analog_read not implemented"
+    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
+    def halt_resume_check
+      raise NotImplementedError, "PiBoard#halt_resume_check not implemented"
     end
-    
-    def remove_listener(pin)
-      @listen_mutex.synchronize do
-        @pin_listeners.delete(pin)
-        @listen_states[pin] = nil
-      end
+
+    def set_register_divider(value)
+      raise NotImplementedError, "PiBoard#set_register_divider not implemented"
+    end
+
+    def set_analog_write_resolution(value)
+      raise NotImplementedError, "PiBoard#set_analog_write_resolution not implemented"
+    end
+
+    def set_analog_read_resolution(value)
+      raise NotImplementedError, "PiBoard#set_analog_read_resolution not implemented"
+    end
+
+    def binary_echo(pin, data=[])
+      raise NotImplementedError, "PiBoard#binary_echo not implemented"
+    end
+
+    def micro_delay(duration)
+      LGPIO.micro_delay(duration)
+    end
+
+    def start_alert_thread
+      start_gpio_reports
+      @alert_thread = Thread.new { loop { get_report } }
+    end
+
+    def stop_alert_thread
+      Thread.kill(@alert_thread) if @alert_thread
+      @alert_thread = nil
     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
+
+    def get_report
+      report = LGPIO.gpio_get_report
+      if report
+        if chip = alert_lut[report[:chip]]
+          if pin = chip[report[:gpio]]
+            update(pin, report[:level])
           end
-          @listen_count += 1
-          sleep(@listen_sleep)
         end
+      else
+        sleep 0.001
       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
-          @listen_sleep = 0 if @listen_sleep < 0
-        end
-      end
+    def start_gpio_reports
+      return if @reporting_started
+      LGPIO.gpio_start_reporting
+      @reporting_started = true
     end
-    
-    def stop_listen_thread
-      @listen_monitor_thread.kill
-      @listen_monitor_thread = nil
-      @listen_thread.kill
-      @listen_thread = nil
+
+    def pin_configs
+      @pin_configs ||= []
     end
   end
 end

data/lib/denko/piboard_core_optimize_lookup.rb

@@ -0,0 +1,31 @@
+#
+# DO NOT REQUIRE THIS FILE. It is evaluated at runtime, if applicable.
+#
+# Optimized method overrides when all GPIO pins are on one gpiochip.
+#
+def digital_write(pin, value)
+  if hardware_pwms[pin]
+    hardware_pwms[pin].duty_percent = (value == 0) ? 0 : 100
+  else
+    LGPIO.gpio_write(__GPIOCHIP_SINGLE_HANDLE__, pin, value)
+  end
+end
+
+def digital_read(pin)
+  if hardware_pwms[pin]
+    state = hardware_pwms[pin].duty_percent
+  else
+    state = LGPIO.gpio_read(__GPIOCHIP_SINGLE_HANDLE__, pin)
+  end
+  self.update(pin, state)
+  return state
+end
+
+def get_report
+  report = LGPIO.gpio_get_report
+  if report
+    update(report[:gpio], report[:level])
+  else
+    sleep REPORT_SLEEP_TIME
+  end
+end

data/lib/denko/piboard_hardware_pwm.rb

@@ -0,0 +1,32 @@
+module Denko
+  class PiBoard
+    # Check if a GPIO number is bound to a hardware PWM.
+    def pin_is_pwm?(pin)
+      map[:pwms][pin]
+    end
+
+    def hardware_pwms
+      @hardware_pwms ||= []
+    end
+
+    def hardware_pwm_from_pin(pin, options={})
+      # Find existing hardware PWM, change the frequency if needed, then return it.
+      frequency = options[:frequency]
+      pwm = hardware_pwms[pin]
+      if pwm
+        pwm.frequency = frequency if (frequency && pwm.frequency != frequency)
+        return pwm
+      end
+
+      # Make sure it's in the board map before trying to use it.
+      raise StandardError, "no hardware PWM in board map for pin #{pin}" unless map[:pwms][pin]
+
+      # Make a new hardware PWM.
+      pwmchip = map[:pwms][pin][:pwmchip]
+      channel = map[:pwms][pin][:channel]
+      frequency ||= 1000
+      pwm = LGPIO::HardwarePWM.new(pwmchip, channel, frequency: frequency)
+      hardware_pwms[pin] = pwm
+    end
+  end
+end

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