denko 0.13.0

data/examples/motor/servo.rb

@@ -0,0 +1,16 @@
+#
+# This is an example of how to use the servo class
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+servo = Denko::Motor::Servo.new(pin: 9, board: board)
+
+# 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|
+  servo.position = angle
+  sleep 0.5
+end

data/examples/motor/stepper.rb

@@ -0,0 +1,43 @@
+#
+# Example driving a stepper motor with the EasyDriver board: https://www.sparkfun.com/products/10267?
+#
+require 'bundler/setup'
+require 'denko'
+
+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.microsteps = 2
+
+# 400 steps is now 1 revolution for a 200 step motor.
+400.times do
+  stepper.step_cc
+  sleep 0.002
+end
+
+# Sleep the driver chip and wait a while.
+stepper.sleep
+sleep 1
+
+# 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.
+#
+200.times do
+  stepper.step_cw
+  sleep 0.006
+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.
+board.finish_write

data/examples/pulse_io/buzzer.rb

@@ -0,0 +1,30 @@
+#
+# Example of playing a melody on a piezoelectric buzzer.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+buzzer = Denko::PulseIO::Buzzer.new(board: board, pin: 9)
+
+C4 = 262
+D4 = 294
+E4 = 330
+
+notes = [
+        [E4, 1], [D4, 1], [C4, 1], [D4, 1], [E4, 1], [E4, 1], [E4, 2],
+        [D4, 1], [D4, 1], [D4, 2],          [E4, 1], [E4, 1], [E4, 2],
+        [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
+end
+
+buzzer.stop
+board.finish_write

data/examples/pulse_io/ir_transmitter.rb

@@ -0,0 +1,55 @@
+#
+# This is a simple test of the IREmitter (infrared blaster) class.
+# It is based on this example from the Arduino library:
+# https://github.com/Arduino-IRremote/Arduino-IRremote/tree/master/examples/SendDemo
+#
+# To verify your emitter is working, you can flash this 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 for serial output.
+#
+# If you don't have 2 boards, use the receive sketch to capture a code from a button
+# of a remote you have. Copy the raw code (long list of numbers in curly braces),
+# and modify it into a Ruby array. 
+#
+# Reflash the denko sketch onto your board and test the IR code operates your device.
+#
+# Both of these methods require you to have an IR receiver handy.
+# If you do not have one, there are IR codes in Raw format for many devices
+# available on sites like http://irdb.tk/codes/
+# When formatted as a string of numbers with + and - in front of each number,
+# you will need to convert them to the array format before use.
+#
+require 'bundler/setup'
+require 'denko'
+
+# Note: If testing with 2 boards connected to the same computer, you want to be
+# explicit about which serial device this script must use. The relevant
+# Connection call is below, but commented out. Enable it and substitute the approriate
+# device  for the board that has the IR emitter connected and denko sketch loaded.
+# Open the receiver board in the Arduino IDE's or another serial monitor.
+#
+connection = Denko::Connection::Serial.new
+# connection = Denko::Connection::Serial.new(device: "/dev/ttyACM0")
+board = Denko::Board.new(connection)
+
+#
+# The IR emitter can be set up on most pins for most boards, but there might be conflicts
+# with other hardware or libraries. Try different pins if one doesn't work.
+#
+ir = Denko::PulseIO::IRTransmitter.new(board: board, pin: 3)
+
+# 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/rtc/ds3231.rb

@@ -0,0 +1,48 @@
+#
+# Example using a D3231 real-time-clock over I2C. Sets the time and reads it
+# 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')
+
+# Tell the bus to search for devices.
+bus.search
+
+# 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)}"
+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
+
+  5.times do
+    puts rtc.time
+    sleep 5
+  end
+end

data/examples/sensor/aht10.rb

@@ -0,0 +1,15 @@
+#
+# Example using AHT21 sensor over I2C, for temperature and humidity.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+aht10 = Denko::Sensor::AHT10.new(bus: bus)
+
+aht10.poll(2) do |reading|
+  puts "Polled Reading: #{reading[:temperature].round(3)} \xC2\xB0C | #{reading[:humidity].round(3)} % RH"
+end
+
+sleep

data/examples/sensor/aht20.rb

@@ -0,0 +1,15 @@
+#
+# Example using AHT21 sensor over I2C, for temperature and humidity.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA0)
+aht20 = Denko::Sensor::AHT20.new(bus: bus)
+
+aht20.poll(2) do |reading|
+  puts "Polled Reading: #{reading[:temperature].round(3)} \xC2\xB0C | #{reading[:humidity].round(3)} % RH"
+end
+
+sleep

data/examples/sensor/bme280.rb

@@ -0,0 +1,75 @@
+#
+# Example using a BME280 sensor over I2C, for temperature, pressure and humidity.
+#
+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: :SDA)
+
+sensor = Denko::Sensor::BME280.new(bus: bus, address: 0x76)
+
+# Use A BMP280 with no humidity instead.
+# sensor = Denko::Sensor::BMP280.new(bus: bus, address: 0x76)
+
+# Default reading mode is oneshot ("forced" in datasheet).
+# sensor.oneshot_mode
+
+# Enable oversampling independently on each sensor.
+# sensor.temperature_samples = 8
+# sensor.pressure_samples = 2
+# sensor.humidity_samples = 4
+
+# Enable continuous reading mode ("normal" in datasheet), with standby time and IIR filter.
+# sensor.continuous_mode
+# sensor.standby_time = 62.5
+# sensor.iir_coefficient = 4
+
+# Print raw config register bits.
+# print sensor.config_register_bits
+
+def display_reading(reading)
+  # Time
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} - "
+  
+  # Temperature
+  formatted_temp = reading[:temperature].round(2).to_s.ljust(5, '0')
+  print "Temperature: #{formatted_temp} \xC2\xB0C"
+  
+  # Pressure
+  if reading[:pressure]
+    formatted_pressure = (reading[:pressure] / 101325).round(5).to_s.ljust(7, '0')
+    print " | Pressure #{formatted_pressure} atm"
+  end
+  
+  # Humidity  
+  if reading[:humidity]
+    formatted_humidity = reading[:humidity].round(2).to_s.ljust(5, '0')
+    print " | Humidity #{formatted_humidity} %"
+  end
+  
+  puts
+end
+
+# Poll the sensor and print readings.
+sensor.poll(5) do |reading|
+  display_reading(reading)
+end
+
+sleep

data/examples/sensor/dht.rb

@@ -0,0 +1,24 @@
+#
+# Example of how to use the DHT class for DHT 11 and DHT 22 sensors.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+dht = Denko::Sensor::DHT.new(pin: 5, board: board)
+
+# The DHT class pre-processes raw data from the board. When it reaches callbacks
+# it's already hash of :temperature and :humidity keys, both with Float values.
+dht.add_callback do |reading|
+  print "#{Time.now.strftime '%Y-%m-%d %H:%M:%S'} | "
+  if reading[:error]
+    puts "Error: #{reading[:error]}"
+  else
+    print "#{reading[:celsius]} \xC2\xB0C | #{reading[:fahrenheit]} \xC2\xB0F | "
+    puts "#{reading[:humidity]}% relative humidity"
+  end
+end
+
+# Read it every 5 seconds.
+dht.poll(5)
+sleep

data/examples/sensor/ds18b20.rb

@@ -0,0 +1,58 @@
+#
+# Example of how to use the Dallas DS18B20 temperature sensor.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::OneWire::Bus.new(pin:4, board: board)
+
+# 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
+    print "#{reading[:celsius]} \xC2\xB0C | #{reading[:fahrenheit]} \xC2\xB0F | "
+    puts "Raw: #{reading[:raw].inspect}"
+  end
+end
+
+ds18b20s.each do |sensor|
+  sensor.poll(5) do |reading|
+    print_reading(reading, sensor)
+  end
+end
+
+sleep

data/examples/sensor/htu21d.rb

@@ -0,0 +1,54 @@
+#
+# Example using HTU21D sensor over I2C, for temperature and humidity.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+htu21d = Denko::Sensor::HTU21D.new(bus: bus)
+
+# Get and set heater state.
+htu21d.heater_on
+puts "Heater on: #{htu21d.heater_on?}"
+htu21d.heater_off
+puts "Heater off: #{htu21d.heater_off?}"
+puts
+
+# Back to default settings, except heater state.
+htu21d.reset
+
+# Only 4 resolution combinations are available, and need to be
+# set by giving a bitmask from the datasheet:
+#   0x00 = 14-bit temperature, 12-bit humidity
+#   0x01 = 12-bit temperature,  8-bit humidity (default)
+#   0x80 = 13-bit temperature, 10-bit humidity
+#   0x81 = 11-bit temperature, 11-bit humidity
+#
+htu21d.resolution = 0x81
+puts "Temperature resolution: #{htu21d.resolution[:temperature]} bits"
+puts "Humidity resolution:    #{htu21d.resolution[:humidity]} bits"
+puts
+
+# Take direct readings by calling methods on the HTU21D instance.
+#   Note: These methods do not take block callbacks like other components.
+#         The HTU21D class doesn't directly implement polling methods either.
+#
+puts "Direct Temperature: #{htu21d.read_temperature.round(3)} \xC2\xB0C"
+puts "Direct Humidity:    #{htu21d.read_humidity.round(3)} %"
+puts
+
+# The last read state can be accessed through sub-objects or [].
+puts "Last Temperature: #{htu21d.temperature.fahrenheit.round(3)} \xC2\xB0F" 
+puts "Last Humidity:    #{htu21d[:humidity].round(3)} %"
+puts
+
+# Poll temperature and humidity at different rates by calling methods on the sub-objects.
+htu21d.temperature.poll(2) do |value|
+  puts "Sub-Object Temperature: #{value.round(3)} \xC2\xB0C"
+end
+htu21d.humidity.poll(4) do |value|
+  puts "Sub-Object Humidity:    #{value.round(3)} %"
+end
+
+sleep

data/examples/sensor/htu31d.rb

@@ -0,0 +1,31 @@
+#
+# Example using HTU31D sensor over I2C, for temperature and humidity.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
+htu31d = Denko::Sensor::HTU31D.new(bus: bus)
+
+# Get and set heater state.
+htu31d.heater_on
+puts "Heater on: #{htu31d.heater_on?}"
+htu31d.heater_off
+puts "Heater off: #{htu31d.heater_off?}"
+
+# Back to default settings, including heater off, unlike HTU21D.
+htu31d.reset
+puts "Resetting HTU31D... Heater off: #{htu31d.heater_off?}"
+puts
+
+# Resolution goes from 0..3 separately for temperature and humidity. See datasheet.
+htu31d.temperature_resolution = 3
+htu31d.humidity_resolution = 3
+
+# Unlike HTU21D, HTU31D works as a regular polled sensor.
+htu31d.poll(2) do |reading|
+  puts "Polled Reading: #{reading[:temperature].round(3)} \xC2\xB0C | #{reading[:humidity].round(3)} % RH"
+end
+
+sleep

data/examples/spi/input_register.rb

@@ -0,0 +1,50 @@
+#
+# Example of a Button connected through an input shift register (CD4021B).
+# Can be used over either a bit bang or hardware SPI interface.
+#
+require 'bundler/setup'
+require 'denko'
+
+# SPI pins (on board)
+SPI_BIT_BANG_PINS   = { clock: 13, input: 12 }
+REGISTER_SELECT_PIN = 9
+
+# Button pin (on register parallel outputs)
+BUTTON_PIN = 0
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+# 1-way (input) bit bang SPI interface on any pins (slower, but flexible).
+bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
+
+# Use the default hardware SPI bus (faster, but predetermined pins).
+# bus = Denko::SPI::Bus.new(board: board)
+
+# Show the hardware SPI pins to aid connection.
+# MOSI = output | MISO = input | SCK = clock
+# puts board.map.select { |name, number| [:MOSI, :MISO, :SCK].include?(name) }
+
+# InputRegister needs a bus and its select pin. The CD4021 likes SPI mode 2.
+# 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::InputRegister.new(bus: bus, pin: REGISTER_SELECT_PIN, spi_mode: 2)
+
+# InputRegister implements enough of the Board interface that digital input
+# components can treat it as a Board. Do that with the Button.
+#
+# button starts listening automatically, which triggers register to start listening,
+# so it can update button as needed. Registers listen with an 8ms interval by default,
+# compared to the 4ms default for a Button directly connected to a Board.
+#
+button = Denko::DigitalIO::Button.new(pin: 0, board: register)
+
+# Button callbacks.
+button.down { puts "Button pressed"  }
+button.up   { puts "Button released" }
+
+# Sleep the main thread. Press the button and callbacks will run.
+sleep

data/examples/spi/output_register.rb

@@ -0,0 +1,49 @@
+#
+# Example of LED connected through an output shift register (74HC595).
+# Can be used over either a bit bang or hardware SPI interface.
+#
+require 'bundler/setup'
+require 'denko'
+
+# SPI pins (on board)
+SPI_BIT_BANG_PINS   = { clock: 13, output: 11 }
+REGISTER_SELECT_PIN = 10
+
+# LED pin (on register parallel outputs)
+LED_PIN = 0
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+# 1-way (output) bit bang SPI interface on any pins (slower, but flexible).
+bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
+
+# Use the default hardware SPI bus (faster, but predetermined pins).
+# bus = Denko::SPI::Bus.new(board: board)
+
+# Show the hardware SPI pins to aid connection.
+# MOSI = output | MISO = input | SCK = clock
+# puts board.map.select { |name, number| [:MOSI, :MISO, :SCK].include?(name) }
+
+# OutputRegister needs a bus and its select pin.
+# 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
+#     write_delay:    0.001      - How long to buffer writes, in seconds
+#     buffer_writes:  true       - Wait for write_delay before writing whole register state.
+#                                  Makes proxied components write pseudo-parallelly.
+#
+register = Denko::SPI::OutputRegister.new(bus: bus, pin: REGISTER_SELECT_PIN)
+
+# We can turn the LED on by writing a 1 to the lowest bit (0) of the register.
+register.write(0b00000001)
+
+# OutputRegister implements enough of the Board interface that digital output
+# components can treat it as a Board. Do that with the LED instead.
+#
+led = Denko::LED.new(board: register, pin: 0)
+
+# Blink the LED and sleep the main thread.
+led.blink 0.5
+sleep

data/examples/spi/ssd_through_register.rb

@@ -0,0 +1,40 @@
+#
+# Example of SevenSegment LED driven though an output shift register (74HC595).
+# Can be used on either a bit bang or hardware SPI interface.
+#
+require 'bundler/setup'
+require 'denko'
+
+# SPI pins (on board)
+SPI_BIT_BANG_PINS   = { clock: 13, output: 11 }
+REGISTER_SELECT_PIN = 10
+
+# SevenSegment pins (on register parallel outputs)
+SEVEN_SEGMENT_PINS = { cathode: 0, a: 1, b: 2, c: 3, d: 4, e: 5, f: 6, g: 7 }
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+# 1-way bit bang SPI bus (slower, but use any pins).
+bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
+
+# Use the default hardware SPI bus (faster, but predetermined pins).
+# bus = Denko::SPI::Bus.new(board: board)
+
+# Show the hardware SPI pins to aid connection.
+# MOSI = output | MISO = input | SCK = clock
+# puts board.map.select { |name, number| [:MOSI, :MISO, :SCK].include?(name) }
+
+# OutputRegister needs a bus and its select pin.
+register = Denko::SPI::OutputRegister.new(bus: bus, pin: REGISTER_SELECT_PIN)
+
+#
+# OutputRegister implements enough of the Board interface that digital output
+# components can treat it as a Board. Do that with the SSD.
+#
+ssd = Denko::LED::SevenSegment.new(board: register, pins: SEVEN_SEGMENT_PINS)
+
+# Turn off the ssd on exit.
+trap("SIGINT") { exit !ssd.off }
+
+# Type a character and press Enter to show it on the SevenSegment LED.
+loop { ssd.display(gets.chomp) }

data/examples/spi/two_registers.rb

@@ -0,0 +1,46 @@
+#
+# Example of 2 SPI devices on the same bus with different select pins.
+# Combination of input_register.rb and output_register.rb
+#
+require 'bundler/setup'
+require 'denko'
+
+# SPI pins (on board)
+SPI_BIT_BANG_PINS   = { clock: 13, input: 12, output: 11 }
+OUT_REGISTER_SELECT = 10
+IN_REGISTER_SELECT  = 9
+
+# LED and Button pins (on their respective registers' parallel pins)
+LED_PIN     = 0
+BUTTON_PIN  = 0
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+# 2-way bit bang SPI bus (slower, but use any pins).
+bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
+
+# Use the default hardware SPI bus (faster, but predetermined pins).
+# bus = Denko::SPI::Bus.new(board: board)
+
+# Show the hardware SPI pins to aid connection.
+# MOSI = output | MISO = input | SCK = clock
+# puts board.map.select { |name, number| [:MOSI, :MISO, :SCK].include?(name) }
+
+# OutputRegister needs a bus and its select pin.
+out_register = Denko::SPI::OutputRegister.new(bus: bus, pin: OUT_REGISTER_SELECT)
+
+# InputRegister needs a bus and its select pin. The CD4021 likes SPI mode 2.
+in_register = Denko::SPI::InputRegister.new(bus: bus, pin: IN_REGISTER_SELECT, spi_mode: 2)
+
+# LED connected to the output register.
+led = Denko::LED.new(board: out_register, pin: LED_PIN)                                 
+
+# Button connected to the input register.
+button = Denko::DigitalIO::Button.new(board: in_register, pin: BUTTON_PIN)
+
+# Button callbacks.
+button.down { led.on;  puts "Button pressed"  }
+button.up   { led.off; puts "Button released" }
+
+# Sleep the main thread. Press the button and callbacks will run.
+sleep

data/examples/uart/bit_bang_read.rb

@@ -0,0 +1,16 @@
+#
+# Example that writes to hardware UART1 and reads back on bit bang UART. Tested on Arduino Mega.
+#
+require 'bundler/setup'
+require 'denko'
+
+board = Denko::Board.new(Denko::Connection::Serial.new)
+
+hw_uart = Denko::UART::Hardware.new(board: board, index: 1, baud: 31250)
+bb_uart = Denko::UART::BitBang.new(board: board, pins: { rx:10, tx:11 }, baud: 31250)
+
+hw_uart.write("Hello World!\n")
+
+sleep 1
+
+puts bb_uart.gets