denko-piboard 0.13.2 → 0.15.0

data/examples/pulse_io/infrared.rb

@@ -0,0 +1,25 @@
+#
+# Send remote control infrared signals on a hardware PWM pin.
+#
+require 'denko/piboard'
+
+# Must be assigned to a hardware PWM channel in your board map.
+PIN = 226
+
+board = Denko::PiBoard.new
+ir = Denko::PulseIO::IRTransmitter.new(board: board, pin: PIN)
+
+# NEC Raw-Data=0xF708FB04. LSBFIRST, so the binary for each hex digit below is backward.
+code =  [ 9000, 4500,                                 # Start bit
+          560, 560, 560, 560, 560, 1690, 560, 560,    # 0010 0x4 command
+          560, 560, 560, 560, 560, 560, 560, 560,     # 0000 0x0 command
+          560, 1690, 560, 1690, 560,560, 560, 1690,   # 1101 0xB command inverted
+          560, 1690, 560, 1690, 560, 1690, 560, 1690, # 1111 0xF command inverted
+          560, 560, 560, 560, 560, 560, 560, 1690,    # 0001 0x8 address
+          560, 560, 560, 560, 560, 560, 560, 560,     # 0000 0x0 address
+          560, 1690, 560, 1690, 560, 1690, 560, 560,  # 1110 0x7 address inverted
+          560, 1690, 560, 1690, 560, 1690, 560, 1690, # 1111 0xF address inverted
+          560]                                        # Stop bit
+
+ir.emit(code)
+board.finish_write

data/examples/sensor/aht10.rb

@@ -0,0 +1,17 @@
+#
+# AHT10 sensor over I2C, for temperature and humidity.
+#
+require 'denko/piboard'
+require_relative 'neat_tph_readings'
+
+board = Denko::PiBoard.new
+# Use the first hardware I2C interface.
+i2c_index = board.map[:i2cs].keys.first
+bus       = Denko::I2C::Bus.new(board: board, index: i2c_index)
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/sensor/dht.rb

@@ -0,0 +1,24 @@
+#
+# Use a DHT class (DHT-11 / DHT-22) sensor for temperature and humidity.
+#
+require 'denko/piboard'
+require_relative 'neat_tph_readings'
+
+DHT_PIN = 267
+
+board = Denko::PiBoard.new
+sensor = Denko::Sensor::DHT.new(board: board, pin: DHT_PIN)
+
+sensor.read
+puts "Temperature unit helpers: #{sensor.temperature} \xC2\xB0C | #{sensor.temperature_f} \xC2\xB0F | #{sensor.temperature_k} K"
+puts
+
+# Don't try to read it again too quickly.
+sleep(1)
+
+# Poll it and print readings.
+sensor.poll(5) do |reading|
+  print_tph_reading(reading)
+end
+
+sleep

data/examples/sensor/ds18b20.rb

@@ -0,0 +1,59 @@
+#
+# Use a Dallas DS18B20 temperature sensor on a 1-Wire bus.
+#
+require 'denko/piboard'
+
+PIN = 256
+
+board = Denko::PiBoard.new
+bus = Denko::OneWire::Bus.new(board: board, pin: PIN)
+
+# The bus detects parasite power automatically when initialized.
+# It can tell that parasite power is in use, but not by WHICH devices.
+if bus.parasite_power
+  puts "Parasite power detected..."; puts
+end
+
+# Call #device_present to reset the bus and return presence pulse as a boolean.
+if bus.device_present?
+  puts "Devices present on bus..."; puts
+else
+  puts "No devices present on bus... Quitting..."
+  return
+end
+
+# Calling #search finds connected devices and stores them in #found_devices.
+# Each hash contains a device's ROM address and matching Ruby class if one exists.
+bus.search
+count = bus.found_devices.count
+puts "Found #{count} device#{'s' if count > 1} on the bus:"
+puts bus.found_devices.inspect; puts
+
+# We can use the search results to setup instances of the device classes.
+ds18b20s = []
+bus.found_devices.each do |d|
+  if d[:class] == Denko::Sensor::DS18B20
+    ds18b20s << d[:class].new(bus: bus, address: d[:address])
+  end
+end
+
+#  Format a reading for printing on a line.
+def print_reading(reading, sensor)
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+  print "Serial(HEX): #{sensor.serial_number} | Res: #{sensor.resolution} bits | "
+
+  if reading[:crc_error]
+    puts "CRC check failed for this reading!"
+  else
+    fahrenheit = (reading[:temperature] * 1.8 + 32).round(1)
+    puts "#{reading[:temperature]} \xC2\xB0C | #{fahrenheit} \xC2\xB0F"
+  end
+end
+
+ds18b20s.each do |sensor|
+  sensor.poll(5) do |reading|
+    print_reading(reading, sensor)
+  end
+end
+
+sleep

data/examples/sensor/hcsr04.rb

@@ -0,0 +1,16 @@
+#
+# Use an HC-SR04 ultrasonic distance sensor.
+#
+require 'denko/piboard'
+
+ECHO_PIN    = 228
+TRIGGER_PIN = 270
+
+board = Denko::PiBoard.new
+hcsr04 = Denko::Sensor::HCSR04.new(board: board, pins: {trigger: TRIGGER_PIN, echo: ECHO_PIN})
+
+hcsr04.poll(1) do |distance|
+  puts "Distance: #{distance} mm"
+end
+
+sleep

data/examples/sensor/neat_tph_readings.rb

@@ -0,0 +1,32 @@
+#
+# This helper method can be used in temp/pressure/humidity sensor examples.
+# Give a hash with readings as float values and it prints them neatly.
+#
+def print_tph_reading(reading)
+  elements = []
+
+  # Temperature
+  if reading[:temperature]
+    formatted_temp = reading[:temperature].to_f.round(2).to_s.ljust(5, '0')
+    elements << "Temperature: #{formatted_temp} \xC2\xB0C"
+  end
+
+  # Pressure
+  if reading[:pressure]
+    formatted_pressure = reading[:pressure].round(2).to_s.ljust(7, '0')
+    elements << "Pressure: #{formatted_pressure} Pa"
+  end
+
+  # Humidity
+  if reading[:humidity]
+    formatted_humidity = reading[:humidity].round(2).to_s.ljust(5, '0')
+    elements << "Humidity: #{formatted_humidity} %"
+  end
+
+  return if elements.empty?
+
+  # Time
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+
+  puts elements.join(" | ")
+end

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,19 @@
-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_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,39 @@
 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          = []
+    include Behaviors::Subcomponents
 
-      # 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 = []
+    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
 
-      # Logic levels
-      @low           = 0
-      @high          = 1
-      @pwm_high      = 255
+      parse_map(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
+    def platform
+      :linux
     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