denko 0.13.1 → 0.13.2

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/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/reader.rb

@@ -12,28 +12,29 @@ module Denko
       end
 
       #
-      # Delegate reading to another method that sends a command to the board. 
-      # Accepts blocks as one-time callbacks stored in the :read key.
-      # Blocks until a value is recieved from the board.
-      # Returns the value after #pre_callback_filter runs on it.
+      # Take a proc/lambda/method as the first agrument and use it to read.
+      # Arguments are passed through, allowing dynamic read methods to be defined.
+      # Eg. send commands (in args) to a bus, then wait for data read back.
+      # 
+      # Block given is added as a one-time callback in the :read key, and 
+      # the curent thread waits until data is received. Returns the result of
+      # calling #pre_callback_filter with the data.
       #
-      # Give procs as methods to build more complex functionality for buses.
-      #
-      def read_using(method, *args, **kwargs, &block)
+      def read_using(reader, *args, **kwargs, &block)
         add_callback(:read, &block) if block_given?
 
-        value = nil
+        return_value = nil
         add_callback(:read) do |filtered_data|
-          value = filtered_data
+          return_value = filtered_data
         end
         
-        method.call(*args, **kwargs)
-        block_until_read
+        reader.call(*args, **kwargs)
+        wait_for_read
 
-        value
+        return_value
       end
       
-      def block_until_read
+      def wait_for_read
         loop do
           break if !callbacks[:read]
           sleep 0.001

data/lib/denko/behaviors/subcomponents.rb

@@ -10,8 +10,6 @@ module Denko
       end
 
       def add_component(component)
-        components << component
-
         if component.respond_to?(:pin) && component.pin.class == Integer
           unless single_pin_components[component.pin]
             single_pin_components[component.pin] = component
@@ -20,6 +18,8 @@ module Denko
                                   "already in use by: #{single_pin_components[component.pin]}"
           end
         end
+
+        components << component
       end
 
       def remove_component(component)

data/lib/denko/board/core.rb

@@ -119,7 +119,7 @@ module Denko
     # CMD = 95
     def set_register_divider(value)
       unless DIVIDERS.include?(value)
-        raise ArgumentError, "error in divider: #{options[:divider]}. Should be one of: #{DIVIDERS.inspect}"
+        raise ArgumentError, "error in divider: #{value}. Should be one of: #{DIVIDERS.inspect}"
       end
       write Message.encode(command: 95, value: value)
     end

data/lib/denko/board/i2c.rb

@@ -7,10 +7,7 @@ module Denko
       3400000 => 0x03,
     }
 
-    # Might make this bigger based on board maps later, but stick with the lowest limit of the AVR boards for now.
-    def i2c_limit
-      32
-    end
+    attr_reader :i2c_limit
 
     def i2c_convert_frequency(freq)
       # Default to 100 kHz.

data/lib/denko/board/map.rb

@@ -6,10 +6,19 @@ module Denko
 
     attr_reader :map
     
+    def substitute_zero_pins
+      ["SDA", "SCL", "MOSI", "MISO", "SCK", "SS"].each do |name|
+        symbol      = name.to_sym
+        zero_symbol = (name + "0").to_sym
+        @map[symbol] = @map[zero_symbol] if (@map[zero_symbol] && !@map[symbol])
+      end
+    end
+
     def load_map(board_name)
       if board_name
         map_path = File.join(MAPS_FOLDER, "#{board_name}.yml")
         @map = YAML.load_file(map_path)
+        substitute_zero_pins
       else
         @map = nil
       end

data/lib/denko/board/servo.rb

@@ -1,15 +1,11 @@
 module Denko
   class Board
     # CMD = 10
-    def servo_toggle(pin, value=:off, options={})
-      options[:min] ||= 544
-      options[:max] ||= 2400
-      aux = pack :uint16, [options[:min], options[:max]]
-
+    def servo_toggle(pin, value=:off, min: 544, max: 2400)
       write Message.encode  command: 10,
                             pin: pin,
                             value: (value == :off) ? 0 : 1,
-                            aux_message: aux
+                            aux_message: pack(:uint16, [min, max])
     end
 
     # CMD = 11