denko 0.13.6 → 0.15.0

data/examples/spi/ssd_through_register.rb

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

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

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

data/examples/uart/bit_bang_write.rb

@@ -1,16 +0,0 @@
-#
-# Example that writes to bit bang UART and reads back on hardware UART1. 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)
-
-bb_uart.write("Hello World!\n")
-
-sleep 1
-
-puts hw_uart.gets

data/examples/uart/board_passthrough.rb

@@ -1,34 +0,0 @@
-#
-# Example using one board's UART as the transport for a second board, also running Denko.
-#
-# For this example, board1 (direct) is an Arduino Mega. board2 (passthrough) is an Uno,
-# running Denko, with its UART pins (0, 1) connected to the Mega's UART1 pins (18, 19)
-#
-# This isn't 100% reliable. The Rx buffer on the direct board is periodically read, so
-# it can potentially overflow, causing data sent from the passthrough board to be lost.
-# Eventually flow control data will be lost and the host will stop sending altogether.
-#
-# Use at your own risk, but for the best possible performance:
-#  1) Avoid long running commands on the direct board (eg. IR transmission, HTU21D).
-#     These block the CPU enough that the Rx buffer won't be read in time to avoid overflow.
-#  2) Use the lowest practical baud rate on the passthrough board. 19200 is used here, so
-#     the direct board's Rx buffer takes 6x the time to fill, compared to 115200 baud.
-#
-require 'bundler/setup'
-require 'denko'
-
-board1 = Denko::Board.new(Denko::Connection::Serial.new)
-
-uart = Denko::UART::Hardware.new(board: board1, index: 1)
-board2 = Denko::Board.new(Denko::Connection::BoardUART.new(uart, baud: 19200))
-
-led1 = Denko::LED.new(board: board1, pin: 13)
-led1.blink(0.02)
-
-led2 = Denko::LED.new(board: board2, pin: 13)
-led2.blink(0.02)
-
-sensor = Denko::AnalogIO::Input.new(board: board1, pin: :A0)
-sensor.listen(4)
-
-sleep

data/examples/uart/hardware_loopback.rb

@@ -1,16 +0,0 @@
-#
-# Example that writes to TX pin of hardware UART1 and reads back on RX pin of same UART.
-#
-require 'bundler/setup'
-require 'denko'
-
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-uart = Denko::UART::Hardware.new(board: board, index: 1, baud: 31250)
-
-uart.write("Hello World!\nBye World!\n")
-
-sleep 1
-
-puts uart.gets
-puts uart.gets

data/lib/denko/analog_io/sensor.rb

@@ -1,6 +0,0 @@
-module Denko
-  module AnalogIO
-    class Sensor < Input
-    end
-  end
-end

data/lib/denko/eeprom/built_in.rb

@@ -1,69 +0,0 @@
-module Denko
-  module EEPROM
-    class BuiltIn
-      include Behaviors::Component
-      include Behaviors::Reader
-
-      public :state=
-
-      def pin
-        254
-      end
-
-      def after_initialize(options={})
-        super(options)
-        self.state = Array.new(board.eeprom_length, nil)
-        load
-      end
-
-      def load
-        state.each_slice(128).with_index do |slice, index|
-          read_using -> { board.eeprom_read(index * 128, slice.length) }
-        end
-      end
-
-      def save
-        @state_mutex.synchronize do
-          @state.each_slice(128).with_index do |slice, index|
-            board.eeprom_write(index * 128, slice)
-          end
-        end
-        load
-      end
-      
-      #
-      # Specific Array-like methods for convenience.
-      # 
-      def length; board.eeprom_length; end
-      alias :count :length
-      
-      def [](index)
-        @state_mutex.synchronize { @state.send :[], index }
-      end
-      
-      def []=(index, value)
-        @state_mutex.synchronize { @state.send :[]=, index, value }
-      end
-      
-      def each(&block)
-        @state_mutex.synchronize { @state.send :each, &block }
-      end
-      
-      def each_with_index(&block)
-        @state_mutex.synchronize { @state.send :each_with_index, &block }
-      end
-      
-      def pre_callback_filter(message)
-        address = message.split("-", 2)[0].to_i
-        bytes = message.split("-", 2)[1].split(",").map(&:to_i)
-        {address: address, data: bytes}
-      end
-
-      def update_state(hash)
-        @state_mutex.synchronize do
-          @state[hash[:address], hash[:data].length] = hash[:data]
-        end
-      end
-    end
-  end
-end

data/lib/denko/fonts.rb

@@ -1,106 +0,0 @@
-module Denko
-  module Fonts
-    #
-    # Adapted from:
-    # https://github.com/lexus2k/ssd1306/blob/master/src/ssd1306_fonts.c
-    #
-    FONT_6x8 = [
-      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00], # sp
-      [0x00, 0x00, 0x00, 0x2f, 0x00, 0x00], # !
-      [0x00, 0x00, 0x07, 0x00, 0x07, 0x00], # "
-      [0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14], # #
-      [0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12], # $
-      [0x00, 0x23, 0x13, 0x08, 0x64, 0x62], # %
-      [0x00, 0x36, 0x49, 0x55, 0x22, 0x50], # &
-      [0x00, 0x00, 0x05, 0x03, 0x00, 0x00], # '
-      [0x00, 0x00, 0x1c, 0x22, 0x41, 0x00], # (
-      [0x00, 0x00, 0x41, 0x22, 0x1c, 0x00], # )
-      [0x00, 0x14, 0x08, 0x3E, 0x08, 0x14], # *
-      [0x00, 0x08, 0x08, 0x3E, 0x08, 0x08], # +
-      [0x00, 0x00, 0x00, 0xA0, 0x60, 0x00], # ,
-      [0x00, 0x08, 0x08, 0x08, 0x08, 0x08], # -
-      [0x00, 0x00, 0x60, 0x60, 0x00, 0x00], # .
-      [0x00, 0x20, 0x10, 0x08, 0x04, 0x02], # /
-      [0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E], # 0
-      [0x00, 0x00, 0x42, 0x7F, 0x40, 0x00], # 1
-      [0x00, 0x42, 0x61, 0x51, 0x49, 0x46], # 2
-      [0x00, 0x21, 0x41, 0x45, 0x4B, 0x31], # 3
-      [0x00, 0x18, 0x14, 0x12, 0x7F, 0x10], # 4
-      [0x00, 0x27, 0x45, 0x45, 0x45, 0x39], # 5
-      [0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30], # 6
-      [0x00, 0x01, 0x71, 0x09, 0x05, 0x03], # 7
-      [0x00, 0x36, 0x49, 0x49, 0x49, 0x36], # 8
-      [0x00, 0x06, 0x49, 0x49, 0x29, 0x1E], # 9
-      [0x00, 0x00, 0x36, 0x36, 0x00, 0x00], # :
-      [0x00, 0x00, 0x56, 0x36, 0x00, 0x00], # ;
-      [0x00, 0x08, 0x14, 0x22, 0x41, 0x00], # <
-      [0x00, 0x14, 0x14, 0x14, 0x14, 0x14], # =
-      [0x00, 0x00, 0x41, 0x22, 0x14, 0x08], # >
-      [0x00, 0x02, 0x01, 0x51, 0x09, 0x06], # ?
-      [0x00, 0x32, 0x49, 0x59, 0x51, 0x3E], # @
-      [0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C], # A
-      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x36], # B
-      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x22], # C
-      [0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C], # D
-      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x41], # E
-      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x01], # F
-      [0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A], # G
-      [0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F], # H
-      [0x00, 0x00, 0x41, 0x7F, 0x41, 0x00], # I
-      [0x00, 0x20, 0x40, 0x41, 0x3F, 0x01], # J
-      [0x00, 0x7F, 0x08, 0x14, 0x22, 0x41], # K
-      [0x00, 0x7F, 0x40, 0x40, 0x40, 0x40], # L
-      [0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F], # M
-      [0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F], # N
-      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E], # O
-      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x06], # P
-      [0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E], # Q
-      [0x00, 0x7F, 0x09, 0x19, 0x29, 0x46], # R
-      [0x00, 0x46, 0x49, 0x49, 0x49, 0x31], # S
-      [0x00, 0x01, 0x01, 0x7F, 0x01, 0x01], # T
-      [0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F], # U
-      [0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F], # V
-      [0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F], # W
-      [0x00, 0x63, 0x14, 0x08, 0x14, 0x63], # X
-      [0x00, 0x07, 0x08, 0x70, 0x08, 0x07], # Y
-      [0x00, 0x61, 0x51, 0x49, 0x45, 0x43], # Z
-      [0x00, 0x00, 0x7F, 0x41, 0x41, 0x00], # [
-      [0x00, 0x02, 0x04, 0x08, 0x10, 0x20], # \
-      [0x00, 0x00, 0x41, 0x41, 0x7F, 0x00], # ]
-      [0x00, 0x04, 0x02, 0x01, 0x02, 0x04], # ^
-      [0x00, 0x40, 0x40, 0x40, 0x40, 0x40], # _
-      [0x00, 0x00, 0x01, 0x02, 0x04, 0x00], # '
-      [0x00, 0x20, 0x54, 0x54, 0x54, 0x78], # a
-      [0x00, 0x7F, 0x48, 0x44, 0x44, 0x38], # b
-      [0x00, 0x38, 0x44, 0x44, 0x44, 0x20], # c
-      [0x00, 0x38, 0x44, 0x44, 0x48, 0x7F], # d
-      [0x00, 0x38, 0x54, 0x54, 0x54, 0x18], # e
-      [0x00, 0x08, 0x7E, 0x09, 0x01, 0x02], # f
-      [0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C], # g
-      [0x00, 0x7F, 0x08, 0x04, 0x04, 0x78], # h
-      [0x00, 0x00, 0x44, 0x7D, 0x40, 0x00], # i
-      [0x00, 0x40, 0x80, 0x84, 0x7D, 0x00], # j
-      [0x00, 0x7F, 0x10, 0x28, 0x44, 0x00], # k
-      [0x00, 0x00, 0x41, 0x7F, 0x40, 0x00], # l
-      [0x00, 0x7C, 0x04, 0x18, 0x04, 0x78], # m
-      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x78], # n
-      [0x00, 0x38, 0x44, 0x44, 0x44, 0x38], # o
-      [0x00, 0xFC, 0x24, 0x24, 0x24, 0x18], # p
-      [0x00, 0x18, 0x24, 0x24, 0x18, 0xFC], # q
-      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x08], # r
-      [0x00, 0x48, 0x54, 0x54, 0x54, 0x20], # s
-      [0x00, 0x04, 0x3F, 0x44, 0x40, 0x20], # t
-      [0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C], # u
-      [0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C], # v
-      [0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C], # w
-      [0x00, 0x44, 0x28, 0x10, 0x28, 0x44], # x
-      [0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C], # y
-      [0x00, 0x44, 0x64, 0x54, 0x4C, 0x44], # z
-      [0x00, 0x00, 0x08, 0x77, 0x00, 0x00], # {
-      [0x00, 0x00, 0x00, 0x7F, 0x00, 0x00], # |
-      [0x00, 0x00, 0x77, 0x08, 0x00, 0x00], # }
-      [0x00, 0x10, 0x08, 0x10, 0x08, 0x00], # ~
-      [0x14, 0x14, 0x14, 0x14, 0x14, 0x14], # horiz lines # DEL
-    ]
-  end
-end

data/lib/denko/sensor/virtual.rb

@@ -1,42 +0,0 @@
-module Denko
-  module Sensor
-    class Temperature
-      include Behaviors::Poller
-
-      def initialize(sensor)
-        @sensor = sensor
-        super
-      end
-
-      def _read
-        @sensor.read_temperature
-      end
-
-      alias :celsius :state
-      alias :to_i    :state
-
-      def fahrenheit
-        (celsius * 9 / 5) + 32
-      end
-
-      def kelvin
-        celsius + 273.15
-      end
-    end
-
-    class Humidity
-      include Behaviors::Poller
-
-      def initialize(sensor)
-        @sensor = sensor
-        super
-      end
-
-      def _read
-        @sensor.read_humidity
-      end
-
-      alias :to_i :state
-    end
-  end
-end

data/src/lib/DenkoIROutESP.cpp

@@ -1,26 +0,0 @@
-//
-// Denko IR output for the ESP8266 and ESP32.
-// Depends on: https://github.com/crankyoldgit/IRremoteESP8266
-// DENKO_IR_OUT must be defeind in DenkoDefines.h
-//
-#include "Denko.h"
-#if defined(DENKO_IR_OUT) && (defined(ESP8266) || defined(ESP32))
-
-#include <IRremoteESP8266.h>
-#include <IRsend.h>
-
-// CMD = 16
-// Send an infrared signal.
-void Denko::irSend(){
-  // Byte 1+ of auxMsg is already little-endian uint16 pulses.
-  uint16_t *pulseArray = reinterpret_cast<uint16_t *>(auxMsg + 1);
-  
-  // Can work on any pin.
-  IRsend infraredOut(pin);
-  infraredOut.begin();
-  
-  // auxMsg[0] is how many pulses were packed.
-  // val is frequency
-  infraredOut.sendRaw(pulseArray, auxMsg[0], val);
-}
-#endif

data/test/eeprom/built_in_test.rb

@@ -1,61 +0,0 @@
-require_relative '../test_helper'
-
-class BoardMock < Denko::Board
-  attr_reader :eeprom_stub
-  
-  def eeprom_read(start_address, length)
-    # Initialize a fake EEPROM
-    @eeprom_stub ||= Array.new(eeprom_length){255}
-    
-    # Pack it up like a string coming from the board.
-    string = @eeprom_stub[start_address, length].map{ |x| x.to_s }.join(",")
-    
-    # Update ourselves with it.
-    self.update("254:#{start_address}-#{string}\n")
-  end
-
-  def eeprom_write(start_address, bytes)
-    @eeprom_stub[start_address, bytes.length] = bytes
-  end
-end
-
-class BuiltInEEPROMTest < Minitest::Test
-  def board
-    @board ||= BoardMock.new
-  end
-
-  def part
-    @part ||= board.eeprom
-  end
-  
-  def test_pin_ee
-    assert_equal part.pin, 254
-  end
-
-  def test_loads_on_initialize_and_updates_correctly
-    assert_equal part.state, Array.new(board.eeprom_length){255}
-  end
-  
-  def test_delegates_to_state_array
-    mock = Minitest::Mock.new
-    mock.expect(:[], 255, [0])
-    mock.expect(:[]=, 128, [1, 128])
-    mock.expect(:each, nil)
-    mock.expect(:each_with_index, nil)
-    
-    part.stub(:state, mock) do
-      part[0]
-      part[1] = 128
-      part.each { |el| el }
-      part.each_with_index { |el| el }
-    end
-  end
-  
-  def test_saves_to_the_board
-    part[0] = 128
-    part[part.length] = 127
-    part.save
-    assert_equal board.eeprom_stub[0], 128
-    assert_equal board.eeprom_stub[board.eeprom_length], 127
-  end
-end

data/tutorial/01-led/led.rb

@@ -1,73 +0,0 @@
-#
-# Example 1: Controlling an LED
-#
-require 'bundler/setup'
-require 'denko'
-
-# If the board is plugged into a USB port, we can connect with serial over USB.
-connection = Denko::Connection::Serial.new
-
-# Create a new board object, giving the connection.
-board = Denko::Board.new(connection)
-
-#
-# Create an LED object, giving the board, and the pin that the positive
-# leg of the LED is connected to. The longer leg is usually positive.
-#
-# See led.pdf in this folder for a hook-up diagram.
-# Use a current limiting resistor with external LEDs to protect them.
-#
-# The on-board LED can also be used. It is connected to pin 13 on most Arduinos,
-# but can vary for other boards. The symbol :LED_BUILTIN should map to the right pin.
-# If it doesn't, change it to the pin number from your board's documentation.
-#
-# Note: Some boards use an addressable LED on-board. In those cases, connect an external
-# LED and use its pin for this example instead.
-#
-led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
-
-# Now we can make it blink.
-puts "Blinking every half second..."
-
-#
-# A digital output can only have one of two states:
-# 1 / high / on
-# 0 / low / off
-# We can use led.digital_write to set it directly, or named convenience methods.
-# These 3 lines all do the same thing: turn on, wait half a second, turn off.
-#
-led.digital_write(1); sleep 0.5; led.digital_write(0)
-led.high;             sleep 0.5; led.low
-led.on;               sleep 0.5; led.off
-
-#
-# led.toggle will set it to the opposite state each time it's called.
-# Keep it blinking for 3 more seconds using #toggle.
-#
-6.times do
-  led.toggle
-  sleep 0.5
-end
-
-#
-# What if we want to blink in the background?
-#
-# led.blink runs in a separate thread, managed by the led, and doesn't block the
-# main thread. Give it the blink interval in seconds.
-#
-led.blink 0.5
-puts "Blinking in the background... Hello from the main thread!"
-sleep 3
-
-#
-# Calling a method that sets the state (#digital_write, #high, #low, #on, #off)
-# automatically stops the blink thread.
-#
-puts "Turning off for 2 seconds..."
-led.off
-sleep 2
-
-# Blink faster indefinitely.
-puts "Blinking faster forever... (Press Ctrl+C to exit)"
-led.blink 0.1
-sleep

data/tutorial/02-button/button.rb

@@ -1,64 +0,0 @@
-#
-# Example 2: Using a Button
-#
-require 'bundler/setup'
-require 'denko'
-
-# Set up the board, connecting with serial over USB.
-board = Denko::Board.new(Denko::Connection::Serial.new)
-
-#
-# Create an object for a momentary button, giving the board, and the pin that
-# the ungrounded side of the button is connected to.
-#
-# `pullup: true` tells the board to keep the input pin high (logical 1) when the
-# button is not pressed. Without this (or an external pullup resistor), the pin
-# might float between 0 and 1, giving incorrect readings. When the button is
-# pressed, it pulls the input pin down to ground (0).
-#
-# See button.pdf in this folder for a hook-up diagram.
-#
-button = Denko::DigitalIO::Button.new(board: board, pin: 7, pullup: true)
-
-#
-# As soon as a Button (or any DigitalInput) is created, the board starts
-# listening for changes to the physical button. When that happens, our button
-# object is notified. To catch these notifications, we have to use a callback.
-# button.add_callback saves a block of code to run each time the button state changes.
-# 
-# The callback below checks if the state is 0 (the button went from up to down),
-# then counts and prints the number of times pressed.
-#
-presses = 0
-button.add_callback(:count_presses) do |state|
-  if state == 0
-    presses = presses + 1
-    puts "Button press ##{presses}"
-  end
-end
-
-# Wait for the button to be pressed 3 times.
-sleep 0.005 while presses < 3
-
-# Button keeps its callbacks in a Hash. We can be specific and use keys to add and remove.
-button.remove_callback(:count_presses)
-
-# Or remove them all. Either way, the block above won't run anymore.
-button.remove_callbacks
-
-#
-# button.down and button.up add callbacks that automatically check state for you.
-#
-# #down runs only when state goes from high (1) to low (0).
-# #up runs only when state goes from low (0) to high (1).
-#
-# We can use them to control the internal LED from example 1.
-#
-led = Denko::LED.new(board: board, pin: 13)
-
-button.up   { led.off } 
-button.down { led.on }
-
-puts "Press the button to turn on the LED... (Ctrl+C to exit)"
-
-sleep