denko 0.13.5 → 0.14.0

data/examples/i2c/search.rb

@@ -5,40 +5,24 @@
 require 'bundler/setup'
 require 'denko'
 
-# Method to let the user set I2C pins.
-def enter_pins
-  puts  "Please manually specify I2C pins..."
-  print "I2C SDA pin: "; sda = gets
-  print "I2C SCL pin: "; scl = gets
-  puts
-  [sda.to_i, scl.to_i]
-end
-
 board = Denko::Board.new(Denko::Connection::Serial.new)
 
-# If no board map, ask user to set pins manually.
-unless board.map
-  puts "Error: Pin map not available for this board"
-  sda, scl = enter_pins
-
-# Else get defaults from map.
-else
+# 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]
-
-  # If not in map, ask user to set manually.
-  unless sda && scl
-    puts "Error: I2C pins not found in this board's pin map"
-    sda, scl = enter_pins
-  end
+  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 "Using I2C interface on pins #{sda} (SDA) and #{scl} (SCL)"
 puts
 
-bus = Denko::I2C::Bus.new(board: board, pin: sda)
+# 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?

data/examples/led/apa102_bounce.rb

@@ -15,10 +15,9 @@ 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
 
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
 # Use the default hardware SPI bus.
-bus = Denko::SPI::Bus.new(board: board)
+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
@@ -27,7 +26,7 @@ loop do
       strip.clear
       strip[index] = color
       strip.show
-      sleep 0.05
+      sleep 0.025
     end
   end
 end

data/examples/led/apa102_fade.rb

@@ -0,0 +1,44 @@
+#
+# 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

data/examples/led/builtin_blink.rb

@@ -4,8 +4,10 @@
 require 'bundler/setup'
 require 'denko'
 
+PIN = :LED_BUILTIN
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
+led = Denko::LED.new(board: board, pin: PIN)
 
 led.blink 0.5
 

data/examples/led/builtin_fade.rb

@@ -0,0 +1,19 @@
+#
+# Blink example for standard built-in LEDs named :LED_BUILTIN
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = :LED_BUILTIN
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+led = Denko::LED.new(board: board, pin: PIN)
+
+min = 0
+max = 100
+values = (min..max).to_a + (min..max-1).to_a.reverse
+
+values.cycle do |value|
+  led.duty = value
+  sleep 0.005
+end

data/examples/led/rgb_led.rb

@@ -0,0 +1,31 @@
+#
+# A standard 3 pin RGB LED (not single pin addressable), on 3 PWM pins.
+#
+require 'bundler/setup'
+require 'denko'
+
+RED_PIN   = 11
+GREEN_PIN = 10
+BLUE_PIN  = 9
+
+board  = Denko::Board.new(Denko::Connection::Serial.new)
+rgb_led = Denko::LED::RGB.new board: board,
+                              pins: {red: RED_PIN, green: GREEN_PIN, blue: BLUE_PIN}
+
+# Set these predefined colors with symbols.
+[:red, :green, :blue, :cyan, :yellow, :magenta, :white, :off].each do |color|
+  rgb_led.color = color
+  sleep 0.5
+end
+
+# Set duty cycle for each "sub LED".
+loop do
+  rgb_led.red.duty   = 100
+  rgb_led.green.duty = 50
+  rgb_led.blue.duty  = 0
+  sleep 0.5
+  rgb_led.red.duty   = 100
+  rgb_led.green.duty = 0
+  rgb_led.blue.duty  = 50
+  sleep 0.5
+end

data/examples/led/seven_segment_char_echo.rb

@@ -1,12 +1,14 @@
 #
-# This is an example of how to use the ssd class
+# Echo pressed keys to a seven segment LED.
 #
 require 'bundler/setup'
 require 'denko'
 
+PINS  = { cathode: 10, a: 3, b: 4, c: 5, d: 6, e: 7, f: 8, g: 9 }
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
 ssd   = Denko::LED::SevenSegment.new board: board,
-                                    pins:  { cathode: 10, a: 3, b: 4, c: 5, d: 6, e: 7, f: 8, g: 9 }
+                                     pins:  PINS
 
 # Turn off the ssd on exit
 trap("SIGINT") { exit !ssd.off }

data/examples/led/ws2812_bounce.rb

@@ -1,24 +1,22 @@
 #
-# Walk a single pixel along the length of a WS2812 strip and back,
-# changing color each time it returns to position 0.
+# Walk a pixel along a WS2812 strip and back, changing color each loop.
 #
 require 'bundler/setup'
 require 'denko'
 
+PIN    = 4
+PIXELS = 8
+
 RED    = [255, 0, 0]
 GREEN  = [0, 255, 0]
 BLUE   = [0, 0, 255]
 WHITE  = [255, 255, 255]
 COLORS = [RED, GREEN, BLUE, WHITE]
 
-WS2812_PIN = 4
-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
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-strip = Denko::LED::WS2812.new(board: board, pin: WS2812_PIN, length: PIXELS)
+strip = Denko::LED::WS2812.new(board: board, pin: PIN, length: PIXELS)
 
 loop do
   COLORS.each do |color|

data/examples/led/ws2812_builtin_blink.rb

@@ -5,11 +5,12 @@
 require 'bundler/setup'
 require 'denko'
 
+PIN   = :LED_BUILTIN
 WHITE = [255, 255, 255]
-OFF = [0, 0, 0]
+OFF   = [0, 0, 0]
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-strip = Denko::LED::WS2812.new(board: board, pin: :LED_BUILTIN, length: 1)
+strip = Denko::LED::WS2812.new(board: board, pin: PIN, length: 1)
 
 loop do
   strip[0] = WHITE

data/examples/led/ws2812_fade.rb

@@ -0,0 +1,43 @@
+#
+# Fade colors along a WS2812, and over time.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN    = 4
+PIXELS = 8
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+strip = Denko::LED::WS2812.new(board: board, pin: PIN, length: PIXELS)
+
+min = 0
+max = 255
+gap = 5
+values = (min..max).step(gap).to_a + (min..max-gap).step(gap).to_a.reverse
+
+color_values= []
+# Red
+values.each { |v| color_values << [v, 0, 0] }
+# Green
+values.each { |v| color_values << [0, v, 0] }
+# Blue
+values.each { |v| color_values << [0, 0, v] }
+# White
+values.each { |v| color_values << [v, v, v] }
+
+loop do
+  start  = 0
+  finish = PIXELS - 1
+  while (finish < color_values.length)
+    slice = color_values[start..finish]
+
+    slice.each_with_index do |value, i|
+      strip[i] = value
+    end
+    strip.show
+    sleep 0.025
+
+    start  += 1
+    finish += 1
+  end
+end

data/examples/motor/l298.rb

@@ -1,27 +1,29 @@
 #
-# Example driving a DC motor with a L298 H-Bridge driver.
+# Drive a DC motor with the L298 H-Bridge driver.
 #
 require 'bundler/setup'
 require 'denko'
 board = Denko::Board.new(Denko::Connection::Serial.new)
 
+PINS = { direction1: 8, direction2: 9, enable: 10 }
+
 # This is only 1 channel of the driver. Make a new object for each channel.
-motor = Denko::Motor::L298.new board: board, pins: {direction1: 8, direction2: 9, enable: 10}
+motor = Denko::Motor::L298.new(board: board, pins: PINS)
 
 # Off without braking (initial state).
 # motor.off
 # motor.idle
 
 # Go forward at half speed for a while.
-motor.forward board.pwm_high / 2
+motor.forward(50)
 sleep 2
 
 # Change direction.
-motor.reverse board.pwm_high / 2
+motor.reverse(50)
 sleep 2
 
 # Speed up without changing direction.
-motor.speed = board.pwm_high
+motor.speed = 100
 sleep 2
 
 # Brake to stop quickly.
@@ -29,13 +31,13 @@ motor.brake
 sleep 1
 
 # Change from brake to forward, but 0 speed.
-motor.forward 0
+motor.forward(0)
 sleep 1
 
-# Gradually speed up.
+# Speed up in 5% increments.
 (1..20).each do |step|
   sleep 0.5
-  motor.speed = (board.pwm_high * (step / 20.0)).round
+  motor.speed = step * 5
 end
 
 # Turn it off.

data/examples/motor/servo.rb

@@ -4,13 +4,14 @@
 require 'bundler/setup'
 require 'denko'
 
+PIN   = 9
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-servo = Denko::Motor::Servo.new(pin: 9, board: board)
+servo = Denko::Motor::Servo.new(board: board, pin: PIN)
 
 # Add different angles (in degrees) to the array below to try out your servo.
 # Note: Some servos may not have a full 180 degree sweep.
-
-[0, 90].cycle do |angle|
+[0, 90, 180, 90].cycle do |angle|
   servo.position = angle
   sleep 0.5
 end

data/examples/motor/stepper.rb

@@ -1,34 +1,34 @@
 #
-# Example driving a stepper motor with the EasyDriver board: https://www.sparkfun.com/products/10267?
+# Use a stepper motor with the EasyDriver board: https://www.sparkfun.com/products/12779
 #
 require 'bundler/setup'
 require 'denko'
 
+PINS = { slp: 6, enable: 7, direction: 8, step: 10, ms1: 11, ms2: 12 }
+
 board = Denko::Board.new(Denko::Connection::Serial.new)
-stepper = Denko::Motor::Stepper.new  board: board,
-                                    pins: { slp: 6, enable: 7, direction: 8, step: 10, ms1: 11, ms2: 12 }
-                                        
-# Default is 8 microsteps. Set to 2 so we can move faster.
+stepper = Denko::Motor::Stepper.new(board: board, pins: PINS)
+
+# Default is 8 microsteps. Use 2 to move faster.
 stepper.microsteps = 2
 
 # 400 steps is now 1 revolution for a 200 step motor.
 400.times do
-  stepper.step_cc
+  stepper.step_ccw
   sleep 0.002
 end
 
-# Sleep the driver chip and wait a while.
+# Sleep the driver and wait a while.
 stepper.sleep
 sleep 1
 
-# Wake it up and set to full steps. 
+# Wake it up and set to full steps.
 stepper.wake
 stepper.microsteps = 1
 
 #
-# Now 200 steps the other way will move us back to the start.
-# Note the longer sleep here since the steps are bigger.
-# Adjust both sleep vales to suit your motor.
+# Now 200 steps the other way will return to the start.
+# Longer sleep times to match bigger steps. Adjust for your motor.
 #
 200.times do
   stepper.step_cw
@@ -38,6 +38,6 @@ end
 # Sleep the driver once we're done.
 stepper.sleep
 
-# We write to the board asynchronously.
-# Make sure we send all step commands before exit.
+# Writing to the board is done asynchronously.
+# Make sure all commands are written before exit.
 board.finish_write

data/examples/one_wire/search.rb

@@ -0,0 +1,32 @@
+#
+# Search a 1-Wire bus.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN   = 4
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus   = Denko::OneWire::Bus.new(board: board, pin: PIN)
+
+# 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
+
+# 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
+
+# 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

data/examples/pulse_io/buzzer.rb

@@ -4,8 +4,10 @@
 require 'bundler/setup'
 require 'denko'
 
-board = Denko::Board.new(Denko::Connection::Serial.new)
-buzzer = Denko::PulseIO::Buzzer.new(board: board, pin: 9)
+PIN    = 9
+
+board  = Denko::Board.new(Denko::Connection::Serial.new)
+buzzer = Denko::PulseIO::Buzzer.new(board: board, pin: PIN)
 
 C4 = 262
 D4 = 294
@@ -17,13 +19,16 @@ notes = [
         [E4, 1], [D4, 1], [C4, 1], [D4, 1], [E4, 1], [E4, 1], [E4, 1], [E4, 1],
         [D4, 1], [D4, 1], [E4, 1], [D4, 1], [C4, 4],
         ]
-        
+
 bpm = 240
 beat_time = 60.to_f / bpm
 
 notes.each do |note|
   buzzer.tone(note[0])
   sleep note[1] * beat_time
+
+  # Stop for a bit so notes are properly defined.
+  buzzer.stop; sleep 0.010
 end
 
 buzzer.stop

data/examples/pulse_io/ir_output.rb

@@ -0,0 +1,51 @@
+#
+# Test of the IROutput (infrared transmitter) class.
+# The specific NEC code is one taken from the Arduino example:
+# https://github.com/Arduino-IRremote/Arduino-IRremote/tree/master/examples/SendDemo
+#
+# To test your emitter works, flash the recieve sketch on a second board:
+# https://github.com/Arduino-IRremote/Arduino-IRremote/tree/master/examples/ReceiveDemo
+# Attach an IR receiver to the receive pin (2 for Atmel AVR) and observe its serial output.
+#
+# If you don't have 2 boards, use that sketch to capture a code from a remote.
+# Copy the raw code (list of numbers in curly braces) and modify into a Ruby array.
+# Put denko firmare back on your board, then test if the IR code operates your device.
+#
+# IR codes are also available from sites like:
+# https://github.com/zmoteio/irdb.tk
+# If formatted numbers with + and - prepended, you need to convert into a Ruby array first.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = 4
+
+# Note: If testing with 2 boards on one computer, be explicit about which serial device
+# runs denko. Use the second Serial.new call below and modify device: as needed.
+# Monitor the receiver board in the Arduino (or some other) serial monitor.
+#
+connection = Denko::Connection::Serial.new
+# connection = Denko::Connection::Serial.new(device: "/dev/ttyACM0")
+board = Denko::Board.new(connection)
+
+#
+# Infrared can be used on most pins for most boards, but there might be conflicts
+# with other hardware or libraries. Try different pins. For more info:
+# https://github.com/Arduino-IRremote/Arduino-IRremote?#timer-and-pin-usage
+#
+ir = Denko::PulseIO::IROutput.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.write(code)
+board.finish_write

data/examples/pulse_io/pwm_output.rb

@@ -0,0 +1,30 @@
+#
+# PWM (pulse width modulation) output demo.
+# Frequency and resolution are configurable (only on ESP32 and PiBoard/Linux for now).
+# Capture output with logic analyzer or oscilloscope to verify accuracy.
+#
+require 'bundler/setup'
+require 'denko'
+
+PIN = 2
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+pwm = Denko::PulseIO::PWMOutput.new(board: board, pin: PIN)
+
+# Resolution test: ~1% duty at 1 kHz / 10-bit.
+# On and off approx. 10us and 990us respectively.
+pwm.pwm_enable(frequency: 1_000, resolution: 10)
+pwm.write 10 # of 1023
+sleep 0.5
+pwm.digital_write 0
+
+sleep 0.5
+
+# Frequency test: ~50% duty at 10 kHz / 8-bit.
+# On and off both approx. 50us.
+pwm.pwm_enable(frequency: 10_000, resolution: 8)
+pwm.write 127 # of 255
+sleep 0.5
+pwm.digital_write 0
+
+board.finish_write

data/examples/rtc/ds3231.rb

@@ -1,48 +1,31 @@
 #
-# Example using a D3231 real-time-clock over I2C. Sets the time and reads it
-# back every 5 seconds.
+# D3231 real-time-clock over I2C. Set time and read back every 5 seconds.
 #
 require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# Default pins for the I2C0 (first) interface on most chips:
-#
-# ATmega 328p:       SDA = 'A4'  SCL = 'A5' - Arduino Uno, Nano
-# ATmega 32u4:       SDA =   2   SCL =   3  - Arduino Leonardo, Pro Micro
-# ATmega1280 / 2560: SDA =  20   SCL =  21  - Arduino Mega
-# SAM3X8E:           SDA =  20   SCL =  21  - Arduino Due
-# SAMD21G18:         SDA =  20   SCL =  21  - Arduino Zero, M0, M0 Pro
-# ESP8266:           SDA =   4   SCL =   5
-# ESP32:             SDA =  21   SCL =  22
-# RP2040:            SDA =   4   SCL =   5  - Raspberry Pi Pico (W)
-#
-# Only give the SDA pin of the I2C bus. SCL (clock) pin must be 
-# connected for it to work, but we don't need to control it.
-#
-bus = Denko::I2C::Bus.new(board: board, pin: 'A4')
+i2c   = Denko::I2C::Bus.new(board: board) # address: 0x68 default
 
 # Tell the bus to search for devices.
-bus.search
+i2c.search
+
+if i2c.found_devices.empty?
+  puts "No I2C devices connected!"
+  return
+end
 
-# Show the found devices.
-puts "No I2C devices connected!" if bus.found_devices.empty?
-bus.found_devices.each do |address|
-  puts "I2C device connected with address: 0x#{address.to_s(16)}"
+# 0x68 is the I2C address for most real time clocks.
+unless (i2c.found_devices.include? 0x68)
+  puts "DS3231 real time clock not found!"
+  return
 end
 
-# 0x68 or 140 is the I2C address for most real time clocks.
-unless (bus.found_devices.include? 0x68)
-  puts "No real time clock found!" unless bus.found_devices.empty?
-else
-  puts; puts "Using real time clock at address 0x68"; puts
-  rtc = Denko::RTC::DS3231.new(bus: bus, address: 0x68)
-  rtc.time = Time.now
+puts "Using DS3231 RTC at address 0x68"; puts
+rtc = Denko::RTC::DS3231.new(bus: i2c, address: 0x68)
+rtc.time = Time.now
 
-  5.times do
-    puts rtc.time
-    sleep 5
-  end
+5.times do
+  puts rtc.time
+  sleep 5
 end

data/examples/sensor/aht10.rb

@@ -1,16 +1,14 @@
 #
-# Example using AHT21 sensor over I2C, for temperature and humidity.
+# AHT10 sensor over I2C, for temperature and humidity.
 #
 require 'bundler/setup'
 require 'denko'
+require_relative 'neat_tph_readings'
 
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+board  = Denko::Board.new(Denko::Connection::Serial.new)
+bus    = Denko::I2C::Bus.new(board: board)
 sensor = Denko::Sensor::AHT10.new(bus: bus) # address: 0x38 default
 
-# Get the shared #print_tph_reading method to print readings neatly.
-require_relative 'neat_tph_readings'
-
 # Poll it and print readings.
 sensor.poll(5) do |reading|
   print_tph_reading(reading)

data/examples/sensor/aht20.rb

@@ -1,16 +1,14 @@
 #
-# Example using AHT21 sensor over I2C, for temperature and humidity.
+# AHT21 sensor over I2C, for temperature and humidity.
 #
 require 'bundler/setup'
 require 'denko'
+require_relative 'neat_tph_readings'
 
-board = Denko::Board.new(Denko::Connection::Serial.new)
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+board  = Denko::Board.new(Denko::Connection::Serial.new)
+bus    = Denko::I2C::Bus.new(board: board)
 sensor = Denko::Sensor::AHT20.new(bus: bus) # address: 0x38 default
 
-# Get the shared #print_tph_reading method to print readings neatly.
-require_relative 'neat_tph_readings'
-
 # Poll it and print readings.
 sensor.poll(5) do |reading|
   print_tph_reading(reading)