denko 0.14.0 → 0.15.0

data/examples/analog_io/ads1115.rb

@@ -1,57 +0,0 @@
-#
-# Example using an ADS1115 ADC over the I2C bus.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus   = Denko::I2C::Bus.new(board: board)
-ads   = Denko::AnalogIO::ADS1115.new(bus: bus)
-
-# Helper method so readings look nice.
-def print_reading(name, raw, voltage)
-  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
-  print "#{name.rjust(18, " ")} | "
-  print "Raw: #{raw.to_s.rjust(6, " ")} | "
-  print "Voltage: "
-  print ("%.10f" % voltage).rjust(13, " ")
-  puts " V"
-end
-
-#
-# Use the ADS1115 directly by writing values to its config registers.
-# ADS1115#read automatically waits for conversion time and gets the 16-bit reading.
-# See datasheet for register bitmaps.
-#
-# Note: This is the only way to use continuous mode. Subcomponents always use one-shot.
-#
-ads.read([0b11000001, 0b10001011]) do |reading|
-  voltage = reading * 0.0001875
-  print_reading("Direct", reading, voltage)
-end
-
-#
-# Or use its BoardProxy interface, adding subcomponents as if it were a Board.
-# The key adc: can substitute for board: when intializing AnalogIO::Input.
-# Gain and sample rate bitmasks can be found in the datasheet.
-#
-# Input on pin 0, with pin 1 as differential negative input, and 6.144 V full range.
-diff_input = Denko::AnalogIO::Input.new(adc: ads, pin: 0, negative_pin: 1, gain: 0b000)
-
-# Input on pin 2 with no negative input (single ended), and 1.024V full range.
-# Ths one uses a 8 SPS rate, essentially 16x oversampling compared to the default 128.
-single_input = Denko::AnalogIO::Input.new(adc: ads, pin: 2, gain: 0b011, sample_rate: 0b000)
-
-# Poll the differential input every second.
-diff_input.poll(1) do |reading|
-  voltage = reading * diff_input.volts_per_bit
-  print_reading("Differential A1-A0", reading, voltage)
-end
-
-# Poll the single ended input every 2 seconds.
-single_input.poll(2) do |reading|
-  voltage = reading * single_input.volts_per_bit
-  print_reading("Single A2-GN", reading, voltage)
-end
-
-sleep

data/examples/analog_io/ads1118.rb

@@ -1,65 +0,0 @@
-#
-# Example using an ADS1118 ADC over the SPI bus.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus   = Denko::SPI::Bus.new(board: board)
-ads   = Denko::AnalogIO::ADS1118.new(bus: bus, pin: 10)
-
-# Helper method so readings look nice.
-def print_reading(name, raw, voltage)
-  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
-  print "#{name.rjust(18, " ")} | "
-  print "Raw: #{raw.to_s.rjust(6, " ")} | "
-  print "Voltage: "
-  print ("%.10f" % voltage).rjust(13, " ")
-  puts " V"
-end
-
-#
-# Read the ADS1118 internal temperature sensor.
-# This always uses the 128 SPS mode, and there is no polling method for it.
-#
-temperature = ads.temperature_read
-puts "ADS1118 Temperature: #{temperature} \xC2\xB0C"
-puts
-
-#
-# Use the ADS1118 directly by writing values to its config registers.
-# ADS1118#read automatically waits for conversion time and gets the 16-bit reading.
-# See datasheet for register bitmaps.
-#
-# Note: This is the only way to use continuous mode. Subcomponents always use one-shot.
-#
-ads.read([0b10000001, 0b10001011]) do |reading|
-  voltage = reading * 0.0001875
-  print_reading("Direct", reading, voltage)
-end
-
-#
-# Or use its BoardProxy interface, adding subcomponents as if it were a Board.
-# The key adc: can substitute for board: when intializing AnalogIO::Input.
-# Gain and sample rate bitmasks can be found in the datasheet.
-#
-# Input on pin 0, with pin 1 as differential negative input, and 6.144 V full range.
-diff_input = Denko::AnalogIO::Input.new(adc: ads, pin: 0, negative_pin: 1, gain: 0b000)
-
-# Input on pin 2 with no negative input (single ended), and 1.024V full range.
-# Ths one uses a 8 SPS rate, essentially 16x oversampling compared to the default 128.
-single_input = Denko::AnalogIO::Input.new(adc: ads, pin: 2, gain: 0b011, sample_rate: 0b000)
-
-# Poll the differential input every second.
-diff_input.poll(1) do |reading|
-  voltage = reading * diff_input.volts_per_bit
-  print_reading("Differential A1-A0", reading, voltage)
-end
-
-# Poll the single ended input every 2 seconds.
-single_input.poll(2) do |reading|
-  voltage = reading * single_input.volts_per_bit
-  print_reading("Single A2-GN", reading, voltage)
-end
-
-sleep

data/examples/analog_io/dac_loopback.rb

@@ -1,34 +0,0 @@
-#
-# Example looping the Arduino Zero's DAC back into one of its ADC pins.
-#
-require 'bundler/setup'
-require 'denko'
-
-#
-# Arduino Zero:   :DAC0 is :A0 is GPIO14
-# Arduino UNO R4: :DAC  is :A0 is GPIO14
-# ESP32 V1:       :DAC0 is GPIO25, :DAC1 is GPIO26, :A4 is GPIO32
-# ESP32-S2:       :DAC0 is GPIO17, :DAC1 is GPIO18, :A4 is GPIO5
-#
-# Connect DAC_PIN TO ADC_PIN with a jumper to test.
-#
-DAC_PIN = :DAC0
-ADC_PIN = :A4
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-dac = Denko::AnalogIO::Output.new(pin: DAC_PIN, board: board)
-adc = Denko::AnalogIO::Input.new(pin: ADC_PIN, board: board)
-
-#
-# Read values should be approximately 4x the written values, since Board#new tries to
-# set output resolution at 8-bits and input to 10-bits. Not configurable on all chips.
-# Scale may be off but, readings should still be proportional.
-#
-[0, 32, 64, 128, 192, 255].each do |output_value|
-  dac.write output_value
-  sleep 1
-  loopback_value = adc.read
-  puts "ADC reads: #{loopback_value} when DAC writes: #{output_value}"
-end
-
-board.finish_write

data/examples/analog_io/input.rb

@@ -1,56 +0,0 @@
-#
-# Use your board's analog-to-digital-converter(ADC) pins with AnalogIO::Input.
-# ADC inputs can be connected to sensors that produce variable output voltage,
-# such as light dependent resistors, or a temperature sensor like the TMP36.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN = :A0
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-input = Denko::AnalogIO::Input.new(pin: PIN, board: board)
-
-# Single read. Blocks main thread during read, then runs given block with the value.
-input.read { |value| puts "#{Time.now} Single read #1: #{value}" }
-
-# Poll repeatedly does single reads, in a separate thread, with an interval in seconds.
-# Given block is saved as a callback, and runs each time a value is received.
-input.poll(0.5) { |value| puts "#{Time.now} Polling: #{value}" }
-
-# Does not block main thread, so wait for some values.
-sleep 3
-# Stop polling, automatically removing callback from #poll.
-input.stop
-
-# "Listening" is where the Board keeps time, reading the ADC at a small interval
-# and continuously sends values, until #stop is called.
-# Powers of 2 from 1 to 128 (in milliseconds) are supported for listener intervals.
-input.listen(32) { |value| puts "#{Time.now} Listening: #{value}" }
-sleep 0.5
-
-# Stop listening. Automatically removes the #listen callback.
-input.stop
-
-# This adds a persistent callback, which runs no matter how a read happens.
-# It will not be removed by #stop.
-input.on_data { |value| puts "#{Time.now} Persistent callback: #{value}" }
-
-# This is a persistent callback with a custom key.
-input.on_data(:test) { |value| puts "#{Time.now} Keyed callback: #{value}"}
-
-# If we do a single read, the two persistent callbacks, and the block given, should run once each.
-input.read { |value| puts "#{Time.now} Single read #2: #{value}" }
-
-# If we listen, the two persistent callbacks, and the block given should run many times.
-input.listen(8) { |value| puts "#{Time.now } Listening again: #{value}" }
-sleep 0.125
-input.stop
-
-# Remove callbacks keyed with :test.
-input.remove_callbacks(:test)
-
-# Remove all callbacks.
-input.remove_callbacks
-
-board.finish_write

data/examples/analog_io/input_smoothing.rb

@@ -1,27 +0,0 @@
-#
-# This example shows how to smooth the input of an AnalogIO::Input.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN = :A0
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-input = Denko::AnalogIO::Input.new(pin: PIN, board: board)
-
-# Enable smoothing on the input using the last 16 values.
-input.smoothing = true
-input.smoothing_size = 16
-
-# Use the slowest listener possible.
-input.listen(128)
-
-#
-# With these settings, the input's state should gradually change (~2 seconds),
-# if you switch its supply from Vcc to Ground (or vice versa), instead of instantaneously.
-#
-# Print the state every 1/4 second. Change the voltage being input to the pin to see results.
-loop do
-  puts input.state
-  sleep(0.25)
-end

data/examples/analog_io/potentiometer.rb

@@ -1,31 +0,0 @@
-#
-# Example for a potentiometer.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN = :A0
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-pot = Denko::AnalogIO::Potentiometer.new(pin: PIN, board: board)
-
-last_percent = nil
-pot.on_data do |reading|
-  # Map reading to a decimal between 0 and 1.
-  fraction = reading / board.adc_high.to_f
-
-  # Linearization hack for audio taper potentiometers.
-  # Adjust k for different tapers. This was an A500K.
-  k = 5
-  linearized = (fraction * (k + 1)) / ((k * fraction) + 1)
-  # Use this for linear potentiometers instead.
-  # linearized = fraction
-
-  percent = (linearized * 100).round
-  unless percent == last_percent
-    puts "Potentiometer: #{percent.to_s.rjust(3, " ")}%"
-    last_percent = percent
-  end
-end
-
-sleep

data/examples/connection/binary_echo.rb

@@ -1,34 +0,0 @@
-#
-# Diagnostic to confirm board is receiving binary data
-# (in aux message) properly.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-echo  = Denko::Connection::BinaryEcho.new(board: board, pin: 253)
-
-min_byte = 0
-max_byte = 255
-
-expected_result = (min_byte..max_byte).to_a.join(',') << ','
-
-waiting    = false
-wait_mutex = Mutex.new
-
-echo.on_data do |data|
-  if data == expected_result
-    puts "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - Echo received"
-    wait_mutex.synchronize { waiting = false }
-  end
-end
-
-loop do
-  wait_mutex.synchronize do
-    unless waiting
-      echo.test_range(min: min_byte, max: max_byte)
-      waiting = true
-    end
-  end
-  sleep 0.001
-end

data/examples/connection/tcp.rb

@@ -1,19 +0,0 @@
-#
-# Connect to a Board via TCP. This works for WiFi and Ethernet sketches.
-# Default port is 3466, and must match the port the Board was flashed to listen on.
-#
-require 'bundler/setup'
-require 'denko'
-
-IP_ADDRESS  = "192.168.0.52"
-PORT        = 3466
-PIN         = :LED_BUILTIN
-
-connection  = Denko::Connection::TCP.new(IP_ADDRESS, PORT)
-board       = Denko::Board.new(connection)
-led         = Denko::LED.new(board: board, pin: PIN)
-
-[:on, :off].cycle do |switch|
-  led.send(switch)
-  sleep 0.5
-end

data/examples/digital_io/button.rb

@@ -1,17 +0,0 @@
-#
-# Simple button example.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN = 3
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-button = Denko::DigitalIO::Button.new board: board,
-                                      pin:   PIN,
-                                      mode:  :input_pullup
-
-button.up   { puts "Button released at #{Time.now.strftime '%H:%M:%S'}" }
-button.down { puts "Button pressed  at #{Time.now.strftime '%H:%M:%S'}" }
-
-sleep

data/examples/digital_io/relay.rb

@@ -1,17 +0,0 @@
-#
-# Use Relays to work with higher voltage circuits. This example
-# closes and opens a relay to send a 500ms pulse on a 12V control circuit.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN = 6
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-relay = Denko::DigitalIO::Relay.new(board: board, pin: PIN)
-
-relay.close
-sleep(0.500)
-relay.open
-
-board.finish_write

data/examples/digital_io/rotary_encoder.rb

@@ -1,36 +0,0 @@
-#
-# KY-040 (30 detent) rotary encoder on a microcontroller, listener at 1ms.
-#
-# WARNING: This method is not precise and may miss steps. Don't use for anything
-# that requires all steps to be read for exact positioning or high speed.
-#
-require 'bundler/setup'
-require 'denko'
-
-PIN_A = 4
-PIN_B = 5
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# Other options and their default values:
-#
-# divider: 1                 # read every divider milliseconds (Board only)
-# debounce_time: 1           # software debounce in microseconds (PiBoard only)
-# counts_per_revolution: 60  # for generic 30 detent rotary encoders
-#
-encoder = Denko::DigitalIO::RotaryEncoder.new board: board,
-                                              pins:  { a: PIN_A, b: PIN_B }
-
-# Reverse direction.
-# encoder.reverse
-
-# Reset count and angle to 0.
-# encoder.reset
-
-encoder.add_callback do |state|
-  change_printable = state[:change].to_s
-  change_printable = "+#{change_printable}" if state[:change] > 0
-  puts "Encoder Change: #{change_printable} | Count: #{state[:count]} | Angle: #{state[:angle]}\xC2\xB0"
-end
-
-sleep

data/examples/display/hd44780.rb

@@ -1,47 +0,0 @@
-#
-# This example writes "Hello World!" in the display
-#
-require 'bundler/setup'
-require 'denko'
-
-# These pins match the SainSmart LCD Keypad Shield for Arduino boards.
-RS = 8
-EN = 9
-D4 = 4
-D5 = 5
-D6 = 6
-D7 = 7
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-lcd   = Denko::Display::HD44780.new  board: board,
-                                     pins: { rs: RS, enable: EN, d4: D4, d5: D5, d6: D6, d7: D7 },
-                                     cols: 16,
-                                     rows: 2
-
-# Bitmap for a custom character. 5 bits wide x 8 high.
-# Useful for generating these: https://omerk.github.io/lcdchargen/
-heart = [	0b00000,
-        	0b00000,
-        	0b01010,
-        	0b11111,
-        	0b11111,
-        	0b01110,
-        	0b00100,
-        	0b00000 ]
-
-# Define the character in CGRAM address 2. 0-7 are usable.
-lcd.create_char(2, heart)
-
-# Need to call home/clear/set_cursor so we go back to writing DDRAM.
-lcd.home
-
-# End the first line with the heart by writing its CGRAM address.
-lcd.print "Hello World!   "
-lcd.write(2)
-
-# Display a clock on second line, updating approximately every second.
-loop do
-  lcd.move_to 0,1
-  lcd.print(Time.now.strftime("%I:%M:%S"))
-  sleep 1
-end

data/examples/display/ssd1306.rb

@@ -1,43 +0,0 @@
-#
-# Example using an SSD1306 driven OLED screen over I2C.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# The SSD1306 OLED connects to either an I2C or SPI bus, depending on the model you have.
-# Bus setup exampels in order:
-#   I2C Hardware
-#   I2C Bit-Bang
-#   SPI Hardware
-#   SPI Bit-Bang
-#
-bus = Denko::I2C::Bus.new(board: board)
-# bus = Denko::I2C::BitBang.new(board: board, pins: {scl: 4, sda: 5})
-# bus = Denko::SPI::Bus.new(board: board)
-# bus = Denko::SPI::BitBang.new(board: board, pins: {clock: 13, output: 11})
-
-# I2C OLED, connected to I2C SDA and SCL.
-oled = Denko::Display::SSD1306.new(bus: bus, rotate: true) # address: 0x3C is default
-# oled = Denko::Display::SH1106.new(bus: bus,rotate: true) # address: 0x3C is default
-
-# SPI OLED, connected to SPI CLK and MOSI pins.
-# select: and dc: pins must be given. reset is optional (can be pulled high instead).
-# oled = Denko::Display::SSD1306.new(bus: bus, pins: { select: 10, dc: 7, reset: 8 }, rotate: true)
-# oled = Denko::Display::SH1106.new(bus: bus, pins: { select: 10, dc: 7, reset: 8}, rotate: true)
-
-# Draw some text on the OLED's canvas (a Ruby memory buffer).
-canvas = oled.canvas
-canvas.text_cursor = [27,60]
-canvas.print("Hello World!")
-
-# Add some shapes to the canvas.
-baseline = 40
-canvas.rectangle(10, baseline, 30, -30)
-canvas.circle(66, baseline - 15, 15)
-canvas.triangle(87, baseline, 117, baseline, 102, baseline - 30)
-
-# Send the canvas to the OLED's graphics RAM so it shows.
-oled.draw
-board.finish_write

data/examples/display/ssd1306_s2_pico.rb

@@ -1,29 +0,0 @@
-#
-# Example using the SSD1306 OLED built into the LOLIN ES32-S2 PICO
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# The OLED's reset pin on this board isn't tied high. Do it manually.
-reset = Denko::DigitalIO::Output.new(board: board, pin: 18)
-reset.high
-
-bus    = Denko::I2C::Bus.new(board: board, pin: :SDA)
-oled   = Denko::Display::SSD1306.new(bus: bus, width: 128, height: 32)
-canvas = oled.canvas
-
-# Draw some text on the OLED's canvas (a Ruby memory buffer).
-canvas.text_cursor = [27,31]
-canvas.print("Hello World!")
-
-# Add some shapes to the canvas.
-baseline = 15
-canvas.rectangle(10, baseline, 15, -15)
-canvas.circle(66, baseline - 7, 8)
-canvas.triangle(102, baseline, 118, baseline, 110, baseline - 15)
-
-# Send the canvas to the OLED's graphics RAM so it shows.
-oled.draw
-board.finish_write

data/examples/eeprom/built_in.rb

@@ -1,32 +0,0 @@
-#
-# Example showing how to load, modify and save the board's EEPROM.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# Initialization automatically gets all EEPROM data from the board.
-# eeprom = Denko::EEPROM::BuiltIn(board: board)
-eeprom = board.eeprom
-
-# EEPROM size reported by the board.
-puts "EEPROM Size: #{eeprom.length} bytes"
-
-# Write values like an array.
-eeprom[0] = 128
-eeprom[1] = 127
-
-# Changes do not save to the board automatically.
-# Call #save to write to the board, and automatically reload from it.
-eeprom.save
-
-# Read values like an array.
-puts "Address 0 contains: #{eeprom[0]}"
-
-# Enumerate like an array.
-eeprom.each_with_index do |byte, address|
-  if address == 1
-    puts "Address #{address} contains #{byte}"
-  end
-end

data/examples/i2c/search.rb

@@ -1,39 +0,0 @@
-#
-# Example that shows the default I2C bus pins, and addresses of any
-# devices connected to the bus.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-# If board has a map, show the pins to the user.
-if board.map
-  puts "Detected board: #{board.name}"
-  sda = board.map[:SDA] || board.map[:SDA0]
-  scl = board.map[:SCL] || board.map[:SCL0]
-  puts "Using default I2C interface on pins #{sda} (SDA) and #{scl} (SCL)"
-else
-  puts "Pin map not available for this board. Using default interface, but SCL and SDA pins unknown"
-end
-puts
-
-# Board's hardware I2C interface on predetermined pins.
-bus = Denko::I2C::Bus.new(board: board)
-# Bit-banged I2C on any pins.
-# bus = Denko::I2C::BitBang.new(board: board, pins: {scl: 8, sda: 9})
-
-bus.search
-
-if bus.found_devices.empty?
-  puts "No devices found on I2C bus"
-else
-  puts "I2C device addresses found:"
-  bus.found_devices.each do |address|
-    # Print as hexadecimal.
-    puts "0x#{address.to_s(16).upcase}"
-  end
-end
-
-puts
-board.finish_write

data/examples/led/apa102_bounce.rb

@@ -1,32 +0,0 @@
-#
-# Walk a single pixel along the length of an APA102 strip and back,
-# changing color each time it returns to position 0.
-#
-require 'bundler/setup'
-require 'denko'
-
-RED    = [255, 0, 0]
-GREEN  = [0, 255, 0]
-BLUE   = [0, 0, 255]
-WHITE  = [255, 255, 255]
-COLORS = [RED, GREEN, BLUE, WHITE]
-PIXELS = 8
-
-# Move along the strip and back, one pixel at a time.
-positions = (0..PIXELS-1).to_a + (1..PIXELS-2).to_a.reverse
-
-# Use the default hardware SPI bus.
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus   = Denko::SPI::Bus.new(board: board)
-strip = Denko::LED::APA102.new(bus: bus, length: PIXELS)
-
-loop do
-  COLORS.each do |color|
-    positions.each do |index|
-      strip.clear
-      strip[index] = color
-      strip.show
-      sleep 0.025
-    end
-  end
-end

data/examples/led/apa102_fade.rb

@@ -1,44 +0,0 @@
-#
-# Fade test for APA102 LED strip.
-#
-require 'bundler/setup'
-require 'denko'
-
-RED    = [255, 0, 0]
-GREEN  = [0, 255, 0]
-BLUE   = [0, 0, 255]
-WHITE  = [255, 255, 255]
-COLORS = [RED, GREEN, BLUE, WHITE]
-PIXELS = 4
-
-# Get all the brightness values as an array.
-brightness_steps = (0..31).to_a + (1..30).to_a.reverse
-
-# Use the default hardware SPI bus.
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus   = Denko::SPI::Bus.new(board: board)
-strip = Denko::LED::APA102.new(bus: bus, length: PIXELS)
-
-strip[0] = RED
-strip[1] = GREEN
-strip[2] = BLUE
-strip[3] = WHITE
-
-# Fade all 4 in sync using global brightness control.
-brightness_steps.each do |value|
-  strip.brightness = value
-  strip.show
-  sleep 0.05
-end
-
-# Set 4th pixel back to full brightness white.
-strip[3] = WHITE + [31]
-
-# Fade per-pixel, in different directions.
-brightness_steps.cycle do |value|
-  strip[0] = RED   +  [value]
-  strip[1] = GREEN +  [31 - value]
-  strip[2] = BLUE  +  [value]
-  strip.show
-  sleep 0.025
-end