denko-piboard 0.13.2 → 0.14.0

data/examples/spi/bb_loopback.rb

@@ -0,0 +1,31 @@
+require 'denko'
+require 'denko/piboard'
+
+CLOCK_PIN  = 256
+INPUT_PIN  = 271
+OUTPUT_PIN = 258
+SELECT_PIN = 272
+
+board = Denko::PiBoard.new
+bus   = Denko::SPI::BitBang.new(board: board, pins: { clock: CLOCK_PIN, input: INPUT_PIN, output: OUTPUT_PIN })
+
+TEST_DATA = [0, 1, 2, 3, 4, 5, 6, 7]
+
+# Create a simple test component class.
+class SPITester
+  include Denko::SPI::Peripheral::SinglePin
+end
+spi_tester = SPITester.new(bus: bus, pin: SELECT_PIN)
+spi_tester.add_callback do |rx_bytes|
+  # If MOSI and MISO are connected this should match TEST_DATA.
+  # If not, should be 8 bytes of 255.
+  puts "RX bytes: #{rx_bytes.inspect}"
+end
+
+# Send the test data.
+puts "TX bytes: #{TEST_DATA.inspect}"
+spi_tester.spi_transfer(write: TEST_DATA, read: 8)
+
+# Wait for read callback to run.
+sleep 1
+board.finish_write

data/examples/spi/loopback.rb

@@ -0,0 +1,37 @@
+require 'denko'
+require 'denko/piboard'
+
+# Use board map from ~/.denko_piboard_map.yml
+board = Denko::PiBoard.new
+
+# Use the first hardware SPI interface, and its defined :cs0 pin.
+spi_index   = board.map[:spis].keys.first
+chip_select = board.map[:spis][spi_index][:cs0]
+bus         = Denko::SPI::Bus.new(board: board, index: spi_index)
+
+TEST_DATA = [0, 1, 2, 3, 4, 5, 6, 7]
+
+# Create a simple test component class.
+class SPITester
+  include Denko::SPI::Peripheral::SinglePin
+end
+spi_tester = SPITester.new(bus: bus, pin: chip_select)
+spi_tester.add_callback do |rx_bytes|
+  # If MOSI and MISO are connected this should match TEST_DATA.
+  # If not, should be 8 bytes of 255.
+  puts "Result      : #{rx_bytes.inspect}"
+end
+
+# Send and receive same data.
+puts "Tx 8 / Rx 8 : #{TEST_DATA.inspect}"
+spi_tester.spi_transfer(write: TEST_DATA, read: 8)
+
+puts "Tx 8 / Rx 12: #{TEST_DATA.inspect}"
+spi_tester.spi_transfer(write: TEST_DATA, read: 12)
+
+puts "Tx 8 / Rx 4 : #{TEST_DATA.inspect}"
+spi_tester.spi_transfer(write: TEST_DATA, read: 4)
+
+# Wait for read callback to run.
+sleep 1
+board.finish_write

data/examples/spi/output_register.rb

@@ -0,0 +1,38 @@
+#
+# Example of LED connected through an output shift register (74HC595).
+# Can be used over either a bit bang or hardware SPI interface.
+#
+require 'denko/piboard'
+
+LED_PIN = 3 # On the register's parallel outputs
+
+# Use board map from ~/.denko_piboard_map.yml
+board = Denko::PiBoard.new
+
+# Use the first hardware SPI interface, and its defined :cs0 pin.
+spi_index   = board.map[:spis].keys.first
+chip_select = board.map[:spis][spi_index][:cs0]
+bus         = Denko::SPI::Bus.new(board: board, index: spi_index)
+
+# OutputRegister needs a bus and pin (chip select).
+# Other options and their defaults:
+#     bytes:          1          - For daisy-chaining registers
+#     spi_frequency:  1000000    - Only affects hardware SPI interfaces
+#     spi_mode:       0
+#     spi_bit_order:  :msbfirst
+#
+register = Denko::SPI::OutputRegister.new(bus: bus, pin: chip_select)
+
+# Turn on the LED by setting the corresponding bit, then writing to the register.
+register.bit_set(LED_PIN, 1)
+register.write
+
+# OutputRegister is a BoardProxy. It has #digital_write, and other methods from Board.
+register.digital_write(LED_PIN, 0)
+
+# DigitalOutputs can treat it as a Board.
+led = Denko::LED.new(board: register, pin: LED_PIN)
+
+# Blink the LED and sleep the main thread.
+led.blink 0.5
+sleep

data/lib/denko/piboard.rb

@@ -1,11 +1,20 @@
-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_hardware_pwm'
+require_relative 'piboard_servo'
 require_relative 'piboard_infrared'
+
 require_relative 'piboard_i2c'
 require_relative 'piboard_spi'
+require_relative 'piboard_led_array'
+
+require_relative 'piboard_i2c_bb'
+require_relative 'piboard_spi_bb'
+require_relative 'piboard_one_wire'

data/lib/denko/piboard_base.rb

@@ -1,81 +1,35 @@
 require 'denko'
-require 'pigpio'
+require 'lgpio'
 
 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 = []
+    include Behaviors::Subcomponents
 
-      # Logic levels
-      @low           = 0
-      @high          = 1
-      @pwm_high      = 255
+    LOW      = 0
+    HIGH     = 1
+    PWM_HIGH = 100
+    def low;      LOW;      end
+    def high;     HIGH;     end
+    def pwm_high; PWM_HIGH; end
+    def analog_write_resolution; 8; end
+
+    def initialize(map_yaml_file=nil)
+      map_yaml_file ||= Dir.home + "/" + DEFAULT_MAP_FILE
+      unless File.exist?(map_yaml_file)
+        raise StandardError, "board map file not given to PiBoard#new, and does not exist at #{map_yaml_file}"
+      end
 
-      # 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
+      parse_map(map_yaml_file)
     end
 
     def finish_write
-      Pigpio::IF.pigpio_stop(@pi_handle)
-      Denko::GPIOD.close_chip
+      gpio_handles.each { |h| LGPIO.chip_close(h) if h }
     end
 
-    #
-    # Use standard Subcomponents behavior.
-    #
-    include Behaviors::Subcomponents
-
-    def update(pin, message, time=nil)
+    def update(pin, message)
       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

@@ -1,94 +1,120 @@
 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_percent = duty
+      else
+        frequency    = pin_configs[pin][:frequency] || 1000
+        handle, line = gpio_tuple(pin)
+        LGPIO.tx_pwm(handle, line, frequency, duty, 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 +122,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,27 @@
+module Denko
+  class PiBoard
+    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