denko 0.13.6 → 0.14.0

data/lib/denko/behaviors/bus_peripheral_addressed.rb

@@ -1,14 +1,16 @@
 module Denko
   module Behaviors
     module BusPeripheralAddressed
-      include Denko::Behaviors::BusPeripheral
+      include BusPeripheral
+      include Lifecycle
 
-      def before_initialize(options={})
-        # Allow @address override in options, even if peripheral sets a default.
-        @address = options[:address] if options[:address]
+      def address
+        @address ||= params[:address]
+      end
 
-        raise ArgumentError, "missing address for #{self}. Try Bus#search first" unless @address
-        super(options)
+      # Validate address presence after initialization.
+      after_initialize do
+        raise ArgumentError, "no address set for for #{self}. Try Bus#search first" unless address
       end
     end
   end

data/lib/denko/behaviors/callbacks.rb

@@ -2,20 +2,19 @@ module Denko
   module Behaviors
     module Callbacks
       include State
-      attr_reader :callback_mutex
 
-      def initialize(options={})
-        @callback_mutex = Mutex.new
-        remove_callbacks
-        super(options)
+      def callback_mutex
+        @callback_mutex ||= Denko.cruby? ? Denko::MutexStub.new : Mutex.new
+        @callback_mutex
       end
 
       def callbacks
-        callback_mutex.synchronize { @callbacks }
+        callback_mutex.synchronize { @callbacks ||= {} }
       end
 
       def add_callback(key=:persistent, &block)
         callback_mutex.synchronize do
+          @callbacks      ||= {}
           @callbacks[key] ||= []
           @callbacks[key] << block
         end
@@ -23,7 +22,7 @@ module Denko
 
       def remove_callback(key=nil)
         callback_mutex.synchronize do
-          key ? @callbacks.delete(key) : @callbacks = {}
+          (@callbacks && key) ? @callbacks.delete(key) : @callbacks = {}
         end
       end
 
@@ -46,6 +45,9 @@ module Denko
         end
 
         callback_mutex.synchronize do
+          break unless @callbacks
+          break if @callbacks.empty?
+
           @callbacks.each_value do |array|
             array.each do |callback|
               callback.call(filtered_data)

data/lib/denko/behaviors/component.rb

@@ -1,28 +1,34 @@
 module Denko
   module Behaviors
     module Component
+      attr_reader :board, :params
       include State
-      attr_reader :board
 
       def initialize(options={})
-        super(options)
-        before_initialize(options)
-        initialize_board(options)
-        convert_pins(options)
-        initialize_pins(options)
+        @params = options
+        run_before_initialize_cbs
+
+        initialize_board
+        convert_pins(params)
+        initialize_pins(params)
         register
-        after_initialize(options)
+
+        run_after_initialize_cbs
       end
 
       def micro_delay(duration)
         board.micro_delay(duration)
       end
 
+      def board_is_register?
+        @board_is_register ||= board.class.ancestors.include?(SPI::BaseRegister)
+      end
+
       protected
 
-      def initialize_board(options={})
-        raise ArgumentError, 'a board is required for a component' unless options[:board]
-        @board = options[:board]
+      def initialize_board
+        raise ArgumentError, 'a board is required for a component' unless params[:board]
+        @board = params[:board]
       end
 
       def register
@@ -36,13 +42,9 @@ module Denko
       # Behaviors::Component only requires a board.
       # Include modules from Setup or override this to use pins.
       #
-      def before_initialize(options={}); end
       def convert_pins(options={});      end
       def initialize_pins(options={});   end
       alias :initialize_pin :initialize_pins
-
-      # Override in components. Call super when inheriting or mixing in.
-      def after_initialize(options={}); end
     end
   end
 end

data/lib/denko/behaviors/input_pin.rb

@@ -1,26 +1,25 @@
 module Denko
   module Behaviors
     module InputPin
+      include Component
       include SinglePin
-      
+      include Lifecycle
+
+      INPUT_MODES = [:input, :input_pulldown, :input_pullup]
+
+      before_initialize do
+        params[:mode] ||= :input
+        unless INPUT_MODES.include?(params[:mode])
+          raise "invalid input mode: #{params[:mode]} given. Should be one of #{INPUT_MODES.inspect}"
+        end
+      end
+
       def _stop_listener
         board.stop_listener(pin)
       end
 
-    protected
-    
-      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
+      def debounce_time=(value)
+        board.set_pin_debounce(pin, value)
       end
     end
   end

data/lib/denko/behaviors/lifecycle.rb

@@ -0,0 +1,51 @@
+module Denko
+  module Behaviors
+    module Lifecycle
+      #
+      # Callback hook DSL for setup work in including classes.
+      # include(Component) in final classes to get callbacks methods.
+      #
+      def self.included(base); base.extend ClassMethods; end
+      #
+      CALLBACK_METHODS = [:before_initialize, :after_initialize]
+
+      # Callback methods themselves.
+      module ClassMethods
+        CALLBACK_METHODS.each do |method_sym|
+          civar_sym = "@#{method_sym}_cbs".to_sym
+          define_method(method_sym) do |&block|
+            if self.instance_variable_defined?(civar_sym)
+              blocks = self.instance_variable_get(civar_sym)
+            else
+              blocks = []
+            end
+            blocks << block
+            self.instance_variable_set(civar_sym, blocks)
+          end
+        end
+      end
+
+      # Instance method runners.
+      CALLBACK_METHODS.each do |method_sym|
+        civar_sym  = "@#{method_sym}_cbs".to_sym
+        runner_sym = "run_#{method_sym}_cbs".to_sym
+
+        define_method(runner_sym) do
+          # Need to check civars in ancestors too.
+          klasses = self.class.ancestors
+          # If running "after" reverse hierarchy so they run top-down.
+          klasses = klasses.reverse if method_sym.match? /after/
+
+          blocks = []
+          klasses.each do |klass|
+            if klass.instance_variable_defined?(civar_sym)
+              blocks << klass.instance_variable_get(civar_sym)
+            end
+          end
+          blocks = blocks.flatten
+          blocks.each { |b| instance_exec(&b) }
+        end
+      end
+    end
+  end
+end

data/lib/denko/behaviors/multi_pin.rb

@@ -3,11 +3,17 @@ module Denko
     module MultiPin
       #
       # Model complex components, using multiple pins, by using proxy components
-      # with one pin each. 
+      # with one pin each.
       #
       include Component
+      include Lifecycle
+
       attr_reader :pin, :pins, :proxies
-      
+
+      def proxies
+        @proxies ||= {}
+      end
+
       # Return a hash with the state of each proxy component.
       def proxy_states
         hash = {}
@@ -16,17 +22,10 @@ module Denko
         end
         hash
       end
-      
-      def before_initialize(options={})
-        # Get given pins early. Avoids giving them again to require or proxy.
-        self.pins = options[:pins]
-        self.proxies = {}
-        super(options)
-      end
 
       def convert_pins(options={})
-        super(options)
-        self.pins.each { |key,pin| self.pins[key] = board.convert_pin(pin) }
+        self.pins = {}
+        params[:pins].each { |key,pin| self.pins[key] = board.convert_pin(pin) }
         pin_array = pins.values
         raise ArgumentError, "duplicate pins in: #{pins.inspect}" unless pin_array == pin_array.uniq
       end
@@ -34,15 +33,20 @@ module Denko
       #
       # Proxy a pin to a single-pin component. Set this up in the including
       # component's #initialize_pins method. Additional options for each proxy
-      # (eg. pullup/pulldown) can be injected there.
-      # 
+      # (eg. mode: :input_pullup) can be injected there.
+      #
       def proxy_pin(name, klass, pin_options={})
         # Proxied pins are required by default.
         require_pin(name) unless pin_options[:optional]
-    
+
         # Make the proxy, passing through options, and store it.
         if self.pins[name]
-          proxy = klass.new pin_options.merge(board: self.board, pin: self.pins[name])          
+          # Allow pin_options to override board or pin number.
+          proxy_options = pin_options
+          proxy_options[:board] ||= self.board
+          proxy_options[:pin]   ||= self.pins[name]
+
+          proxy = klass.new(proxy_options)
           self.proxies[name] = proxy
           instance_variable_set("@#{name}", proxy)
         end
@@ -50,7 +54,7 @@ module Denko
         # Accessor for the proxy's instance var, or nil, if not given.
         singleton_class.class_eval { attr_reader name }
       end
-      
+
       #
       # Require a single pin that may or may not be proxied. This is useful for
       # components using libraries running on the board, where we need to specify
@@ -63,9 +67,9 @@ module Denko
       def require_pins(*array)
         [array].flatten.each { |name| require_pin(name) }
       end
-      
+
       private
-      
+
       attr_writer :pins, :proxies
     end
   end

data/lib/denko/behaviors/output_pin.rb

@@ -1,12 +1,17 @@
 module Denko
   module Behaviors
     module OutputPin
+      include Component
       include SinglePin
-      protected
+      include Lifecycle
 
-      def initialize_pins(options={})
-        super(options)
-        self.mode = :output
+      OUTPUT_MODES = [:output, :output_pwm, :output_dac, :output_open_drain, :output_open_source]
+
+      before_initialize do
+        params[:mode] ||= :output
+        unless OUTPUT_MODES.include?(params[:mode])
+          raise "invalid input mode: #{params[:mode]} given. Should be one of #{OUTPUT_MODES.inspect}"
+        end
       end
     end
   end

data/lib/denko/behaviors/single_pin.rb

@@ -18,6 +18,7 @@ module Denko
 
       def initialize_pins(options={})
         @pin = options[:pin]
+        self.mode = params[:mode] if params[:mode]
       end
     end
   end

data/lib/denko/behaviors/state.rb

@@ -1,22 +1,28 @@
 module Denko
   module Behaviors
     module State
-      def initialize(options={})
-        # Component includes State, so no need to call super here.
-        @state_mutex = Mutex.new
-        @state = nil
+      include Lifecycle
+
+      # Force state initialization.
+      after_initialize do
+        state
+      end
+
+      def state_mutex
+        @state_mutex ||= Denko.cruby? ? Denko::MutexStub.new : Mutex.new
+        @state_mutex
       end
-      
+
       def state
-        @state_mutex.synchronize { @state }
+        state_mutex.synchronize { @state }
       end
-      
+
       protected
 
       def state=(value)
-        @state_mutex.synchronize { @state = value }
+        state_mutex.synchronize { @state = value }
       end
-      
+
       def update_state(value)
         self.state = value if value
       end

data/lib/denko/behaviors/subcomponents.rb

@@ -1,15 +1,32 @@
 module Denko
   module Behaviors
     module Subcomponents
-      def components
-        @components ||= []
+      #
+      # Main Methods
+      #
+      def add_component(component)
+        add_single_pin(component)
+        add_hw_i2c(component)
+        add_hw_spi(component)
+        components << component
       end
 
-      def single_pin_components
-        @single_pin_components ||= {}
+      def remove_component(component)
+        remove_single_pin(component)
+        remove_hw_i2c(component)
+        remove_hw_spi(component)
+        deleted = components.delete(component)
+        component.stop if deleted && component.respond_to?(:stop)
       end
 
-      def add_component(component)
+      def components
+        @components ||= []
+      end
+
+      #
+      # Single Pin
+      #
+      def add_single_pin(component)
         if component.respond_to?(:pin) && component.pin.class == Integer
           unless single_pin_components[component.pin]
             single_pin_components[component.pin] = component
@@ -18,17 +35,60 @@ module Denko
                                   "already in use by: #{single_pin_components[component.pin]}"
           end
         end
-
-        components << component
       end
 
-      def remove_component(component)
+      def remove_single_pin(component)
         if component.respond_to?(:pin) && component.pin.class == Integer
-          single_pin_components[component.pin] = nil
+          single_pin_components.delete(component.pin)
         end
-        
-        deleted = components.delete(component)
-        component.stop if deleted && component.respond_to?(:stop)
+      end
+
+      def single_pin_components
+        @single_pin_components ||= {}
+      end
+
+      #
+      # I2C
+      #
+      def add_hw_i2c(component)
+        if component.respond_to?(:i2c_index)
+          unless hw_i2c_comps[component.i2c_index]
+            hw_i2c_comps[component.i2c_index] = component
+          else
+            raise StandardError,  "Error adding #{component} to #{self}. I2C dev: #{component.i2c_index} " \
+                                  "already in use by: #{hw_i2c_comps[component.i2c_index]}"
+          end
+        end
+      end
+
+      def remove_hw_i2c(component)
+        hw_i2c_comps.delete(component.i2c_index) if component.respond_to?(:i2c_index)
+      end
+
+      def hw_i2c_comps
+        @hw_i2c_comps ||= {}
+      end
+
+      #
+      # SPI
+      #
+      def add_hw_spi(component)
+        if component.respond_to?(:spi_index)
+          unless hw_spi_comps[component.spi_index]
+            hw_spi_comps[component.spi_index] = component
+          else
+            raise StandardError,  "Error adding #{component} to #{self}. SPI dev: #{component.spi_index} " \
+                                  "already in use by: #{hw_spi_comps[component.spi_index]}"
+          end
+        end
+      end
+
+      def remove_hw_spi(component)
+        hw_spi_comps.delete(component.spi_index) if component.respond_to?(:spi_index)
+      end
+
+      def hw_spi_comps
+        @hw_spi_comps ||= {}
       end
     end
   end

data/lib/denko/behaviors.rb

@@ -1,13 +1,14 @@
 module Denko
   module Behaviors
     # Pin and component setup stuff
+    autoload :Lifecycle,  "#{__dir__}/behaviors/lifecycle"
     autoload :State,      "#{__dir__}/behaviors/state"
     autoload :Component,  "#{__dir__}/behaviors/component"
     autoload :SinglePin,  "#{__dir__}/behaviors/single_pin"
     autoload :InputPin,   "#{__dir__}/behaviors/input_pin"
     autoload :OutputPin,  "#{__dir__}/behaviors/output_pin"
     autoload :MultiPin,   "#{__dir__}/behaviors/multi_pin"
- 
+
     # Subcomponent stuff
     autoload :Subcomponents,          "#{__dir__}/behaviors/subcomponents"
     autoload :BusController,          "#{__dir__}/behaviors/bus_controller"

data/lib/denko/board/core.rb

@@ -3,29 +3,44 @@ module Denko
     DIVIDERS = [1, 2, 4, 8, 16, 32, 64, 128]
 
     PIN_MODES = {
-                  output:         0b000,
-                  output_pwm:     0b010,
-                  output_dac:     0b100,
-                  input:          0b001,
-                  input_pulldown: 0b011,
-                  input_pullup:   0b101,
-                  input_output:   0b111
+                  output:             0b0000,
+                  output_pwm:         0b0010,
+                  output_dac:         0b0100,
+                  output_open_drain:  0b0110,
+                  output_open_source: 0b1000,
+                  input:              0b0001,
+                  input_pulldown:     0b0011,
+                  input_pullup:       0b0101,
     }
 
     # CMD = 0
-    def set_pin_mode(pin, mode=:input)
+    def set_pin_mode(pin, mode=:input, options={})
       unless PIN_MODES.keys.include? mode
         raise ArgumentError, "cannot set mode: #{mode}. Should be one of: #{PIN_MODES.keys.inspect}"
       end
+
+      # Set frequency and resolution for PWM if given.
+      aux = nil
+      if (mode == :output_pwm) && options
+        aux    = [0, 0]
+        aux[0] = options[:frequency] if options[:frequency]
+        aux[1] = options[:resolution] if options[:resolution]
+        aux = pack :uint32, aux, min: 8, max: 8
+      end
+
       write Message.encode  command: 0,
                             pin: pin,
-                            value: PIN_MODES[mode]
+                            value: PIN_MODES[mode],
+                            aux_message: aux
+    end
+
+    def set_pin_debounce(pin, debounce_time)
     end
 
     # CMD = 1
     def digital_write(pin,value)
       unless (value == 1) || (value == 0)
-        raise ArgumentError, "cannot write digital value: #{value}. Should be Integer either 0 or 1" 
+        raise ArgumentError, "cannot write digital value: #{value}. Should be Integer either 0 or 1"
       end
       write Message.encode command: 1, pin: pin, value: value
     end
@@ -37,12 +52,10 @@ module Denko
 
     # CMD = 3
     def pwm_write(pin,value)
-      if  (value < 0) || (value > pwm_high)
-        raise ArgumentError, "cannot write PWM value: #{value}. Should be Integer in range 0..#{pwm_high} "
-      end
+      raise ArgumentError, "PWM value cannot be negative" if (value < 0)
       write Message.encode command: 3, pin: pin, value: value.round
     end
-    
+
     # CMD = 4
     def dac_write(pin,value)
       if (value < 0) || (value > dac_high)
@@ -60,7 +73,7 @@ module Denko
     def set_listener(pin, state=:off, **options)
       # Default to digital listener and validate.
       options[:mode] ||= :digital
-      unless (options[:mode] == :digital) || (options[:mode] == :analog) 
+      unless (options[:mode] == :digital) || (options[:mode] == :analog)
         raise ArgumentError, "error in mode: #{options[:mode]}. Should be one of: [:digital, :analog]"
       end
       mode_byte = (options[:mode] == :digital) ? 0 : 1
@@ -71,7 +84,7 @@ module Denko
       else
         options[:divider] ||= 16
       end
-      
+
       # Convert divider to exponent and validate.
       exponent = Math.log2(options[:divider]).round
       if (exponent < 0) || (exponent > 7)
@@ -79,7 +92,7 @@ module Denko
       end
 
       # Validate state.
-      unless (state == :on) || (state == :off) 
+      unless (state == :on) || (state == :off)
         raise ArgumentError, "error in state: #{options[:state]}. Should be one of: [:on, :off]"
       end
       state_byte = (state == :on) ? 1 : 0
@@ -131,7 +144,7 @@ module Denko
       end
       write Message.encode(command: 96, value: value)
     end
-    
+
     # CMD = 97
     def set_analog_read_resolution(value)
       if (value < 0) || (value > 16)
@@ -140,6 +153,11 @@ module Denko
       write Message.encode(command: 97, value: value)
     end
 
+    # CMD = 98
+    def binary_echo(pin, data=[])
+      write Message.encode command: 98, pin: pin, value: data.length, aux_message: pack(:uint8, data)
+    end
+
     # CMD = 99
     def micro_delay(duration)
       if (duration < 0) || (duration > 0xFFFF)

data/lib/denko/board/i2c.rb

@@ -14,38 +14,37 @@ module Denko
       freq = 100000 unless freq
 
       unless I2C_FREQUENCIES.include?(freq)
-        raise ArgumentError, "I2C frequency must be in: #{I2C_FREQUENCIES.keys.inspect}" 
+        raise ArgumentError, "I2C frequency must be in: #{I2C_FREQUENCIES.keys.inspect}"
       end
       I2C_FREQUENCIES[freq]
     end
 
     # CMD = 33
-    def i2c_search
+    def i2c_search(i2c_index)
       write Message.encode command: 33
     end
 
     # CMD = 34
-    def i2c_write(address, bytes, frequency=100000, repeated_start=false)
+    def i2c_write(i2c_index, address, bytes, frequency=100000, repeated_start=false)
       bytes = [bytes] unless bytes.class == Array
       raise ArgumentError, "I2C write must be 1..#{i2c_limit} bytes long" if (bytes.length > i2c_limit || bytes.length < 1)
-      
+
       # Use top bit of address to select stop condition (1), or repated start (0).
       send_stop = repeated_start ? 0 : 1
-      frequency = i2c_convert_frequency(frequency)
-      
+
       write Message.encode  command:     34,
-                            pin:         address | (send_stop << 7),
-                            value:       bytes.length,
-                            aux_message: pack(:uint8, frequency) + pack(:uint8, bytes)
+                            aux_message: pack(:uint8, i2c_convert_frequency(frequency)) +
+                                         pack(:uint8, address | (send_stop << 7)) +
+                                         pack(:uint8, bytes.length) +
+                                         pack(:uint8, bytes)
     end
 
     # CMD = 35
-    def i2c_read(address, register, read_length, frequency=100000, repeated_start=false)
+    def i2c_read(i2c_index, address, register, read_length, frequency=100000, repeated_start=false)
       raise ArgumentError, "I2C read must be 1..#{i2c_limit} bytes long" if (read_length > i2c_limit || read_length < 1)
 
       # Use top bit of address to select stop condition (1), or repated start (0).
       send_stop = repeated_start ? 0 : 1
-      frequency = i2c_convert_frequency(frequency)
 
       # A register address starting register address can be given (up to 4 bytes)
       if register
@@ -57,9 +56,10 @@ module Denko
       end
 
       write Message.encode  command:      35,
-                            pin:          address | (send_stop << 7),
-                            value:        read_length,
-                            aux_message:  pack(:uint8, frequency) + register_packed
+                            aux_message:  pack(:uint8, i2c_convert_frequency(frequency)) +
+                                          pack(:uint8, address | (send_stop << 7)) +
+                                          pack(:uint8, read_length) +
+                                          register_packed
     end
   end
 end