denko 0.13.0 → 0.13.2

data/examples/analog_io/ads1118.rb

@@ -14,12 +14,12 @@ bus = Denko::SPI::Bus.new(board: board)
 # bus = Denko::SPI::BitBang.new(board: board, pins: SPI_BIT_BANG_PINS)
 
 # Connect chip select/enable pin of the ADS1118 to pin 9.
-ads1118 = Denko::AnalogIO::ADS1118.new(bus: bus, pin: 9)
+ads = Denko::AnalogIO::ADS1118.new(bus: bus, pin: 9)
 
 # 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(12, " ")} | "
+  print "#{name.rjust(18, " ")} | "
   print "Raw: #{raw.to_s.rjust(6, " ")} | "
   print "Voltage: "
   print ("%.10f" % voltage).rjust(13, " ")
@@ -30,7 +30,7 @@ end
 # Read the ADS1118 internal temperature sensor.
 # This always uses the 128 SPS mode, and there is no polling method for it.
 # 
-temperature = ads1118.temperature_read
+temperature = ads.temperature_read
 puts "ADS1118 Temperature: #{temperature} \xC2\xB0C"
 puts
 
@@ -41,7 +41,7 @@ puts
 #
 # Note: This is the only way to use continuous mode. Subcomponents always use one-shot.
 #
-ads1118.read([0b10000001, 0b10001011]) do |reading|
+ads.read([0b10000001, 0b10001011]) do |reading|
   voltage = reading * 0.0001875
   print_reading("Direct", reading, voltage)
 end
@@ -49,26 +49,25 @@ 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: ads1118, pin: 0, negative_pin: 1, gain: 0b000)
+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: ads1118, pin: 2, gain: 0b011, sample_rate: 0b000)
+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", reading, voltage)
+  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", reading, voltage)
+  print_reading("Single A2-GN", reading, voltage)
 end
 
 sleep

data/examples/analog_io/dac_loopback.rb

@@ -5,13 +5,15 @@ require 'bundler/setup'
 require 'denko'
 
 #
-# For the Arduino Zero: 'DAC0' = 'A0' = GPIO14.
-# For the ESP32 V1:     'DAC0' = GPIO25, 'DAC1' = GPIO26, `ADC1_4` = 32
+# 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 = 'A5'
+DAC_PIN = :DAC0
+ADC_PIN = :A4
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
 dac = Denko::AnalogIO::Output.new(pin: DAC_PIN, board: board)

data/examples/analog_io/input.rb

@@ -1,52 +1,55 @@
 #
-# This is an example of how to use the sensor class
-# You must register data callbacks and have the main thread
-# sleep or in someway keep running or your program
-# will exit before any callbacks can be called
+# This example shows how to use your board's analog-to-digital-converter(ADC) pins,
+# through the AnalogIO::Input class. ADC inputs can be connected to sensors
+# which produce a variable output voltage, such as light dependent resistors,
+# or a simple temperature sensor like the TMP36.
 #
 require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-sensor = Denko::AnalogIO::Sensor.new(pin: 'A0', board: board)
-
-# Single read with block as callback. Blocks main thread.
-# Callback fires only once then is removed automatically.
-sensor.read { |value| puts "#{Time.now} Single read: #{value}" }
-
-# Poll the sensor every 1 second with block as callback. Does not block main thread.
-# Callback fires every time data is received until #stop is called.
-sensor.poll(1) { |value| puts "#{Time.now} Polling: #{value}" }
-sleep 5
-
-# Stop polling. Automatically removes the callback from the #poll block.
-sensor.stop
-
-# Continuous listen with block as callback. Fires every time data is received until #stop is called.
-sensor.listen { |value| puts "#{Time.now} Listening: #{value}" }
+input = Denko::AnalogIO::Input.new(pin: :A0, board: board)
+
+# Single read that blocks the main thread. When a value is received, the given
+# code block runs only once, and then the main thread continues.
+input.read { |value| puts "#{Time.now} Single read #1: #{value}" }
+
+# Read (poll) the input every half second. This happens in a separate thread, 
+# so sleep the main thread for a while to get some values.
+# Given code block is added as a callback, and runs every time a value is received.
+input.poll(0.5) { |value| puts "#{Time.now} Polling: #{value}" }
+sleep 3
+
+# Stop polling. Automatically removes the #poll callback.
+input.stop
+
+# Listening is similar to polling. The board reads the input and sends the value
+# every time interval, except it's keeping time. We only send the initial command,
+# not one for each read. Smaller intervals like 32 milliseconds are possible.
+# Powers of 2 from 1 to 128 are supported for listener intervals.
+input.listen(32) { |value| puts "#{Time.now} Listening: #{value}" }
 sleep 0.5
 
-# Stop listening. Automatically removes the callback from the #listen block.
-sensor.stop
-
-# Add a persistent callback.
-sensor.on_data { |value| puts "#{Time.now} Persistent callback: #{value}" }
+# Stop listening. Automatically removes the #listen callback.
+input.stop
 
-# Add a callback with a custom key.
-sensor.on_data(:test) { |value| puts "#{Time.now} Keyed callback: #{value}"}
+# 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}" }
 
-# Single read again. Block given fires only once. Callbacks added with #on_data fire also.
-sensor.read { |value| puts "#{Time.now} Single read again: #{value}" }
+# This is a persistent callback with a custom key.
+input.on_data(:test) { |value| puts "#{Time.now} Keyed callback: #{value}"}
 
-# Continuous listen. Block fires each time. Callbacks added with #on_data continue to fire.
-sensor.listen { |value| puts "#{Time.now } Listening again: #{value}" }
-sleep 0.5
+# 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}" }
 
-# Stop listening. Automatically removes the callback from the #listen block.
-sensor.stop
+# 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.
-sensor.remove_callbacks(:test)
+input.remove_callbacks(:test)
 
 # Remove all callbacks.
-sensor.remove_callbacks
+input.remove_callbacks

data/examples/connection/tcp.rb

@@ -11,7 +11,7 @@ connection = Denko::Connection::TCP.new("192.168.0.77", 3466)
 # connection =  Denko::Connection::TCP.new("192.168.1.2", 3466)
 #
 board = Denko::Board.new(connection)
-led = Denko::Led.new(pin: 13, board: board)
+led = Denko::LED.new(board: board, pin: :LED_BUILTIN)
 
 [:on, :off].cycle do |switch|
   led.send(switch)

data/examples/display/hd44780.rb

@@ -6,9 +6,9 @@ require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
 lcd = Denko::Display::HD44780.new  board: board,
-                                  pins: { rs: 8, enable: 9, d4: 4, d5: 5, d6: 6, d7: 7 },
-                                  cols: 16,
-                                  rows: 2
+                                   pins: { rs: 8, enable: 9, d4: 4, d5: 5, d6: 6, d7: 7 },
+                                   cols: 16,
+                                   rows: 2
 
 # Bitmap for a custom character. 5 bits wide x 8 high.
 # Useful for generating these: https://omerk.github.io/lcdchargen/

data/examples/display/ssd1306.rb

@@ -21,7 +21,7 @@ board = Denko::Board.new(Denko::Connection::Serial.new)
 # 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')
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
 oled = Denko::Display::SSD1306.new(bus: bus, rotate: true)
 canvas = oled.canvas
 

data/examples/pulse_io/buzzer.rb

@@ -7,6 +7,7 @@ require 'denko'
 board = Denko::Board.new(Denko::Connection::Serial.new)
 buzzer = Denko::PulseIO::Buzzer.new(board: board, pin: 9)
 
+=begin
 C4 = 262
 D4 = 294
 E4 = 330
@@ -28,3 +29,42 @@ end
 
 buzzer.stop
 board.finish_write
+=end
+
+
+
+AS3 = 233
+BN3 = 257
+DS4 = 311
+FN4 = 349
+FS4 = 370
+GS4 = 415
+
+notes = [
+  [AS3, 1],       [AS3, 1],             [AS3, 1], [AS3, 1],
+  [AS3, 0.75], [BN3, 0.75], [DS4, 0.5], [AS3, 1], [AS3, 0.5], [nil, 0.5],
+  [AS3, 0.75], [BN3, 0.75], [DS4, 0.5], [AS3, 1], [AS3, 0.5], [nil, 0.5],
+  [AS3, 0.75], [BN3, 0.75], [DS4, 0.5], [FN4, 1], [FN4, 0.5], [nil, 0.5],
+  [GS4, 0.75], [FS4, 0.75], [FN4, 0.5], [DS4, 1], [DS4, 0.5], [nil, 0.5],
+  [GS4, 0.75], [FS4, 0.75], [FN4, 0.5], [DS4, 1], [DS4, 0.5], [nil, 0.5],
+  [AS3, 0.75], [BN3, 0.75], [DS4, 0.5], [AS3, 1], [AS3, 0.5], [nil, 0.5],
+  [AS3, 0.75], [BN3, 0.75], [DS4, 0.5], [AS3, 1], [AS3, 0.5], [nil, 0.5],
+]
+  
+bpm = 135
+beat_time = 60.to_f / bpm
+
+notes.each do |note|
+  if note[0]
+    buzzer.tone(note[0])
+    sleep(note[1] * beat_time)
+  else
+    buzzer.stop
+    sleep((note[1] * beat_time))
+  end
+  buzzer.stop
+  buzzer.micro_delay(5)
+end
+
+buzzer.stop
+board.finish_write

data/examples/sensor/aht20.rb

@@ -5,7 +5,7 @@ require 'bundler/setup'
 require 'denko'
 
 board = Denko::Board.new(Denko::Connection::Serial.new)
-bus = Denko::I2C::Bus.new(board: board, pin: :SDA0)
+bus = Denko::I2C::Bus.new(board: board, pin: :SDA)
 aht20 = Denko::Sensor::AHT20.new(bus: bus)
 
 aht20.poll(2) do |reading|

data/lib/denko/analog_io/ads1115.rb

@@ -0,0 +1,61 @@
+module Denko
+  module AnalogIO
+    class ADS1115
+      include I2C::Peripheral
+      include ADS111X
+
+      # Config register values on startup. MSB-first.
+      # Matches datasheet, except MSB bit 7 unset to avoid conversion start.
+      # Same as: [0x05, 0x83] or [5, 131]
+      CONFIG_STARTUP = [0b00000101, 0b10000011]
+
+      # Base config bytes to mask settings into. Not same as startup config.
+      # MSB bits 0 and 7 set to enable single-shot mode.
+      # LSB bits 0 and 1 set to disable comparator.
+      BASE_MSB = 0b10000001
+      BASE_LSB = 0b00000011
+
+      # Register addresses.
+      CONFIG_ADDRESS     = 0b01
+      CONVERSION_ADDRESS = 0b00
+
+      def before_initialize(options={})
+        @i2c_address   = 0x48
+        @i2c_frequency = 400_000
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Mutex and variables for BoardProxy behavior.
+        @mutex        = Mutex.new
+        @active_pin   = nil
+        @active_gain  = nil
+
+        # Set register bytes to default and write to device.
+        @config_register = CONFIG_STARTUP.dup
+        i2c_write [CONFIG_ADDRESS] + @config_register
+
+        # Enable BoardProxy callbacks.
+        enable_proxy
+      end
+
+      def _read(config)
+        # Write config register to start reading.
+        i2c_write [CONFIG_ADDRESS] + config
+        
+        # Sleep the right amount of time for conversion, based on sample rate bits.
+        sleep WAIT_TIMES[config[1] >> 5]
+
+        # Read the result, triggering callbacks.
+        i2c_read(CONVERSION_ADDRESS, 2)
+      end
+
+      # Readings are 2 bytes big-endian.
+      def pre_callback_filter(bytes)
+        bytes.pack("C*").unpack("s>")[0]
+      end
+    end
+  end
+end

data/lib/denko/analog_io/ads1118.rb

@@ -2,55 +2,18 @@ module Denko
   module AnalogIO
     class ADS1118
       include SPI::Peripheral
-      include Behaviors::Reader
-      include Behaviors::Threaded
+      include ADS111X
 
-      PGA_SETTINGS = [  # Bitmask   Full scale voltage
-        0.0001875,      # 0b000     6.144 V
-        0.000125,       # 0b001     4.095 V
-        0.0000625,      # 0b010     2.048 V (default)
-        0.00003125,     # 0b011     1.024 V
-        0.000015625,    # 0b100     0.512 V
-        0.0000078125,   # 0b101     0.256 V
-        0.0000078125,   # 0b110     0.256 V
-        0.0000078125,   # 0b111     0.256 V
-      ]
-      PGA_RANGE = (0..7).to_a
-
-      # Sample rate bitmask maps to sample time in seconds.
-      SAMPLE_TIMES = [  # Bitmask
-        0.125,          # 0b000
-        0.0625,         # 0b001
-        0.03125,        # 0b010
-        0.015625,       # 0b011
-        0.0078125,      # 0b100 (default)
-        0.004,          # 0b101
-        0.002105263,    # 0b110
-        0.00116279,     # 0b111
-      ]
-      SAMPLE_RATE_RANGE = (0..7).to_a
-
-      # Wait times need to be slightly longer than the actual sample times.
-      WAIT_TIMES = SAMPLE_TIMES.map { |time| time + 0.0005 }
-
-      # Mux bits map to array of form [positive input, negative input].
-      MUX_SETTINGS = {
-        0b000 => [0, 1],
-        0b001 => [0, 3],
-        0b010 => [1, 3],
-        0b011 => [2, 3],
-        0b100 => [0, nil],
-        0b101 => [1, nil],
-        0b110 => [2, nil],
-        0b111 => [3, nil],
-      }
-
-      # Config register values on startup.
-      CONFIG_DEFAULT = [0x05, 0x8B]
+      # Config register values on startup. MSB-first.
+      # Matches datasheet. Same as: [0x05, 0x8B] or [5, 139]
+      CONFIG_STARTUP = [0b00000101, 0b10001011]
 
       # Base config bytes to mask settings into. Not same as default.
+      # MSB bits 0 and 7 set to enable single-shot mode.
+      # LSB bit 3 set to enable pullup resistor on MISO pin.
+      # LSB bit 1 set to flag valid data in the NOP bits.
       BASE_MSB = 0b10000001
-      BASE_LSB = 0b00001011
+      BASE_LSB = 0b00001010
 
       def after_initialize(options={})
         super(options)
@@ -64,7 +27,7 @@ module Denko
         @active_gain  = nil
 
         # Set register bytes to default and write to device.
-        @config_register = CONFIG_DEFAULT.dup
+        @config_register = CONFIG_STARTUP.dup
         spi_write(@config_register)
 
         # Enable BoardProxy callbacks.
@@ -82,7 +45,7 @@ module Denko
         spi_read(2)
       end
 
-      # Pack the 2 bytes back into a string, then unpack as big-endian int16.
+      # Pack the 2 bytes back into a string, then unpack as big-endian signed int16.
       def pre_callback_filter(message)
         bytes = message.split(",").map { |b| b.to_i }
         bytes.pack("C*").unpack("s>")[0]
@@ -104,79 +67,6 @@ module Denko
         block.call(temperature) if block_given?
         return temperature
       end
-
-      #
-      # BoardProxy behavior so AnalogIO classes can use this as a Board.
-      #
-      include Behaviors::BoardProxy
-
-      # Mimic Board#update, but inside a callback, wrapped by #update.
-      def enable_proxy
-        self.add_callback(:board_proxy) do |value|
-          components.each do |component|
-            if @active_pin == component.pin
-              component.volts_per_bit = PGA_SETTINGS[@active_gain]
-              component.update(value) 
-            end
-          end
-        end
-      end
-
-      def analog_read(pin, negative_pin=nil, gain=nil, sample_rate=nil)
-        # Wrap in mutex so calls and callbacks are atomic.
-        @mutex.synchronize do
-          # Default gain and sample rate.
-          gain        ||= 0b010
-          sample_rate ||= 0b100
-
-          # Set these for callbacks.
-          @active_pin   = pin
-          @active_gain  = gain
-
-          # Set gain in upper config register.
-          raise ArgumentError "wrong gain: #{gain.inspect} given for ADS1118" unless PGA_RANGE.include?(gain)
-          @config_register[0] = BASE_MSB | (gain << 1)
-
-          # Set mux bits in upper config register.
-          mux_bits = pins_to_mux_bits(pin, negative_pin)
-          @config_register[0] = @config_register[0] | (mux_bits << 4)
-
-          # Set sample rate in lower config_register.
-          raise ArgumentError "wrong sample_rate: #{sample_rate.inspect} given for ADS1118" unless SAMPLE_RATE_RANGE.include?(gain)
-          @config_register[1] = BASE_LSB | (sample_rate << 5)
-
-          read(@config_register)
-        end
-      end
-
-      def pins_to_mux_bits(pin, negative_pin)
-        # Pin 1 is negative input. Only pin 0 can be read.
-        if negative_pin == 1
-          raise ArgumentError, "given pin: #{pin.inspect} cannot be used when pin 1 is negative input, only 0" unless pin == 0
-          return 0b000
-        end
-
-        # Pin 3 is negative input. Pins 0..2 can be read.
-        if negative_pin == 3
-          raise ArgumentError, "given pin: #{pin.inspect} cannot be used when pin 3 is negative input, only 0..2" unless [0,1,2].include? pin
-          return 0b001 + pin
-        end
-
-        # No negative input. Any pin from 0 to 3 can be read.
-        unless negative_pin
-          raise ArgumentError, "given pin: #{pin.inspect} is out of range 0..3" unless [0,1,2,3].include? pin
-          return (0b100 + pin)
-        end
-
-        raise ArgumentError, "only pins 1 and 3 can be used as negative input"
-      end
-
-      def analog_listen(pin, divider=nil)
-        raise StandardError, "ADS1118 does not implement #listen for subcomponents. Use #read or #poll instead"
-      end
-
-      def stop_listener(pin)
-      end
     end
   end
 end

data/lib/denko/analog_io/ads111x.rb

@@ -0,0 +1,123 @@
+module Denko
+  module AnalogIO
+    module ADS111X
+      #
+      # Functionality shared among the ADS111X class of ADC converters.
+      #
+      include Behaviors::Reader
+
+      PGA_SETTINGS = [  # Bitmask   Full scale voltage
+        0.0001875,      # 0b000     6.144 V
+        0.000125,       # 0b001     4.095 V
+        0.0000625,      # 0b010     2.048 V (default)
+        0.00003125,     # 0b011     1.024 V
+        0.000015625,    # 0b100     0.512 V
+        0.0000078125,   # 0b101     0.256 V
+        0.0000078125,   # 0b110     0.256 V
+        0.0000078125,   # 0b111     0.256 V
+      ]
+      PGA_RANGE = (0..7).to_a
+
+      # Sample rate bitmask maps to sample time in seconds.
+      SAMPLE_TIMES = [  # Bitmask
+        0.125,          # 0b000
+        0.0625,         # 0b001
+        0.03125,        # 0b010
+        0.015625,       # 0b011
+        0.0078125,      # 0b100 (default)
+        0.004,          # 0b101
+        0.002105263,    # 0b110
+        0.00116279,     # 0b111
+      ]
+      SAMPLE_RATE_RANGE = (0..7).to_a
+
+      # Wait times need to be slightly longer than the actual sample times.
+      WAIT_TIMES = SAMPLE_TIMES.map { |time| time + 0.0005 }
+
+      # Mux bits map to array of form [positive input, negative input].
+      MUX_SETTINGS = {
+        0b000 => [0, 1],
+        0b001 => [0, 3],
+        0b010 => [1, 3],
+        0b011 => [2, 3],
+        0b100 => [0, nil],
+        0b101 => [1, nil],
+        0b110 => [2, nil],
+        0b111 => [3, nil],
+      }
+
+      #
+      # BoardProxy behavior so AnalogIO classes can use this as a Board.
+      #
+      include Behaviors::BoardProxy
+
+      # Mimic Board#update, but inside a callback, wrapped by #update.
+      def enable_proxy
+        self.add_callback(:board_proxy) do |value|
+          components.each do |component|
+            if @active_pin == component.pin
+              component.volts_per_bit = PGA_SETTINGS[@active_gain]
+              component.update(value) 
+            end
+          end
+        end
+      end
+
+      def analog_read(pin, negative_pin=nil, gain=nil, sample_rate=nil)
+        # Wrap in mutex so calls and callbacks are atomic.
+        @mutex.synchronize do
+          # Default gain and sample rate.
+          gain        ||= 0b010
+          sample_rate ||= 0b100
+
+          # Set these for callbacks.
+          @active_pin   = pin
+          @active_gain  = gain
+
+          # Set gain in upper config register.
+          raise ArgumentError "wrong gain: #{gain.inspect} given for ADS111X" unless PGA_RANGE.include?(gain)
+          @config_register[0] = self.class::BASE_MSB | (gain << 1)
+
+          # Set mux bits in upper config register.
+          mux_bits = pins_to_mux_bits(pin, negative_pin)
+          @config_register[0] = @config_register[0] | (mux_bits << 4)
+
+          # Set sample rate in lower config_register.
+          raise ArgumentError "wrong sample_rate: #{sample_rate.inspect} given for ADS111X" unless SAMPLE_RATE_RANGE.include?(gain)
+          @config_register[1] = self.class::BASE_LSB | (sample_rate << 5)
+
+          read(@config_register)
+        end
+      end
+
+      def pins_to_mux_bits(pin, negative_pin)
+        # Pin 1 is negative input. Only pin 0 can be read.
+        if negative_pin == 1
+          raise ArgumentError, "given pin: #{pin.inspect} cannot be used when pin 1 is negative input, only 0" unless pin == 0
+          return 0b000
+        end
+
+        # Pin 3 is negative input. Pins 0..2 can be read.
+        if negative_pin == 3
+          raise ArgumentError, "given pin: #{pin.inspect} cannot be used when pin 3 is negative input, only 0..2" unless [0,1,2].include? pin
+          return 0b001 + pin
+        end
+
+        # No negative input. Any pin from 0 to 3 can be read.
+        unless negative_pin
+          raise ArgumentError, "given pin: #{pin.inspect} is out of range 0..3" unless [0,1,2,3].include? pin
+          return (0b100 + pin)
+        end
+
+        raise ArgumentError, "only pins 1 and 3 can be used as negative input"
+      end
+
+      def analog_listen(pin, divider=nil)
+        raise StandardError, "ADS111X does not implement #listen for subcomponents. Use #read or #poll instead"
+      end
+
+      def stop_listener(pin)
+      end
+    end
+  end
+end

data/lib/denko/analog_io/output.rb

@@ -13,7 +13,8 @@ module Denko
       end
 
       def write(value)
-        board.dac_write(pin, @state = value)
+        @board.dac_write(@pin, value)
+        self.state = value
       end
     end
   end

data/lib/denko/analog_io.rb

@@ -4,6 +4,8 @@ module Denko
     autoload :Output,         "#{__dir__}/analog_io/output"
     autoload :Potentiometer,  "#{__dir__}/analog_io/potentiometer"
     autoload :Sensor,         "#{__dir__}/analog_io/sensor"
+    autoload :ADS111X,        "#{__dir__}/analog_io/ads111x"
+    autoload :ADS1115,        "#{__dir__}/analog_io/ads1115"
     autoload :ADS1118,        "#{__dir__}/analog_io/ads1118"
   end
 end

data/lib/denko/behaviors/bus_peripheral_addressed.rb

@@ -4,7 +4,7 @@ module Denko
       include Denko::Behaviors::BusPeripheral
 
       def before_initialize(options={})
-        # Aallow @address override in options, even if peripheral sets default.
+        # Allow @address override in options, even if peripheral sets a default.
         @address = options[:address] if options[:address]
 
         raise ArgumentError, "missing address for #{self}. Try Bus#search first" unless @address

data/lib/denko/behaviors/component.rb

@@ -33,7 +33,7 @@ module Denko
         board.remove_component(self)
       end
 
-      # Setup::Base only requires a board.
+      # Behaviors::Component only requires a board.
       # Include modules from Setup or override this to use pins.
       #
       def before_initialize(options={}); end

data/lib/denko/behaviors/input_pin.rb

@@ -12,9 +12,12 @@ module Denko
       def initialize_pins(options={})
         super(options)
         
+        # Assume input direction, and look for pull mode in options.
         initial_mode = :input
         initial_mode = :input_pullup   if options[:pullup]
         initial_mode = :input_pulldown if options[:pulldown]
+
+        # If user was explicit about mode, just use that.
         initial_mode = options[:mode]  if options[:mode]
         
         self.mode = initial_mode