denko 0.14.0 → 0.15.0

data/lib/denko/behaviors/callbacks.rb

@@ -1,29 +1,32 @@
 module Denko
   module Behaviors
     module Callbacks
+      include Lifecycle
       include State
 
-      def callback_mutex
-        @callback_mutex ||= Denko.cruby? ? Denko::MutexStub.new : Mutex.new
-        @callback_mutex
+      after_initialize do
+        @callback_mutex = Denko.gil? ? Denko::MutexStub.new : Mutex.new
+        callbacks
       end
 
       def callbacks
-        callback_mutex.synchronize { @callbacks ||= {} }
+        @callbacks ||= {}
       end
 
       def add_callback(key=:persistent, &block)
-        callback_mutex.synchronize do
-          @callbacks      ||= {}
-          @callbacks[key] ||= []
-          @callbacks[key] << block
-        end
+        @callback_mutex.lock
+        @callbacks      ||= {}
+        @callbacks[key] ||= []
+        @callbacks[key] << block
+        @callback_mutex.unlock
+        @callbacks
       end
 
       def remove_callback(key=nil)
-        callback_mutex.synchronize do
-          (@callbacks && key) ? @callbacks.delete(key) : @callbacks = {}
-        end
+        @callback_mutex.lock
+        (@callbacks && key) ? @callbacks.delete(key) : @callbacks = {}
+        @callback_mutex.unlock
+        @callbacks
       end
 
       alias :on_data :add_callback
@@ -44,10 +47,8 @@ module Denko
           return nil
         end
 
-        callback_mutex.synchronize do
-          break unless @callbacks
-          break if @callbacks.empty?
-
+        @callback_mutex.lock
+        if @callbacks && !@callbacks.empty?
           @callbacks.each_value do |array|
             array.each do |callback|
               callback.call(filtered_data)
@@ -56,6 +57,7 @@ module Denko
           # Remove one-time callbacks added by #read.
           @callbacks.delete(:read)
         end
+        @callback_mutex.unlock
 
         update_state(filtered_data)
       end

data/lib/denko/behaviors/component.rb

@@ -20,10 +20,6 @@ module Denko
         board.micro_delay(duration)
       end
 
-      def board_is_register?
-        @board_is_register ||= board.class.ancestors.include?(SPI::BaseRegister)
-      end
-
       protected
 
       def initialize_board

data/lib/denko/behaviors/lifecycle.rb

@@ -34,7 +34,7 @@ module Denko
           # 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/
+          klasses = klasses.reverse if method_sym.to_s.start_with? "after"
 
           blocks = []
           klasses.each do |klass|

data/lib/denko/behaviors/listener.rb

@@ -2,20 +2,26 @@ module Denko
   module Behaviors
     module Listener
       include Callbacks
-      
+
       attr_reader :divider
 
+      #
+      # These delegate to #_listen and #_stop_listener,
+      # which should be defined in the including class.
+      #
       def listen(divider=nil, &block)
-        @divider = divider || @listener
+        @divider = divider
         stop
         add_callback(:listen, &block) if block_given?
         _listen(@divider)
+        @listening = true
       end
 
       def stop
-        super if defined?(super)
+        begin; super; rescue NoMethodError; end
         _stop_listener
         remove_callbacks :listen
+        @listening = false
       end
     end
   end

data/lib/denko/behaviors/multi_pin.rb

@@ -24,8 +24,10 @@ module Denko
       end
 
       def convert_pins(options={})
-        self.pins = {}
-        params[:pins].each { |key,pin| self.pins[key] = board.convert_pin(pin) }
+        @pins = {}
+        params[:pins].each do |key,pin|
+          self.pins[key] = pin ? board.convert_pin(pin) : nil
+        end
         pin_array = pins.values
         raise ArgumentError, "duplicate pins in: #{pins.inspect}" unless pin_array == pin_array.uniq
       end
@@ -67,10 +69,6 @@ module Denko
       def require_pins(*array)
         [array].flatten.each { |name| require_pin(name) }
       end
-
-      private
-
-      attr_writer :pins, :proxies
     end
   end
 end

data/lib/denko/behaviors/poller.rb

@@ -3,8 +3,10 @@ module Denko
     module Poller
       include Reader
       include Threaded
-      
+
       def poll_using(method, interval, *args, &block)
+        mruby_thread_check
+
         unless [Integer, Float].include? interval.class
           raise ArgumentError, "wrong interval given to #poll : #{interval.inspect}"
         end
@@ -13,7 +15,14 @@ module Denko
         add_callback(:poll, &block) if block_given?
 
         threaded_loop do
+          # Lock, THEN wait for other normal reads to finish.
+          @reader_mutex.lock
+          sleep 0.001 while read_busy?
+          @reading_normally = true
+
           method.call(*args)
+          @reader_mutex.unlock
+
           sleep interval
         end
       end
@@ -23,7 +32,7 @@ module Denko
       end
 
       def stop
-        super if defined?(super)
+        begin; super; rescue NoMethodError; end
         remove_callbacks :poll
       end
     end

data/lib/denko/behaviors/reader.rb

@@ -1,49 +1,137 @@
 module Denko
   module Behaviors
     module Reader
+      include Lifecycle
       include Callbacks
 
       #
-      # Defalt behavior for #read is to delegate to #_read.
-      # Define #_read in including classes.
+      # DO NOT REPLACE with MutexStub on CRuby!
+      # Even with GIL, misordered readings possible with multiple threads.
+      #
+      after_initialize do
+        # mruby doesn't have Thread or Mutex, so only stub there.
+        @reader_mutex = Denko.mruby? ? Denko::MutexStub.new : Mutex.new
+      end
+
+      READ_WAIT_TIME = 0.001
+      #
+      # Override #update to allow "raw reads" or "normal reads":
+      #
+      #   - Normal reads perform normal #update behavior, passing through
+      #     #pre_callback_filter, running all callbacks and returning filtered_data.
+      #     Use normal for anything that updates the state of a component, and handle
+      #     that in in #pre_callback_filter and #update_state.
+      #     May or may not block calling thread, depending on platform.
+      #
+      #   - Raw reads bypass #pre_callback_filter, callbacks, and return
+      #     raw data. Use raw for reading things like sensor config/serial etc.
+      #     DOES NOT take block callbacks from the use. ALWAYS handle the return value.
+      #     ALWAYS blocks the calling thread.
+      #
+      def update(data)
+        if @reading_raw
+          @callback_mutex.lock
+          @callbacks[:read_raw].each { |c| c.call(data) }
+          @callbacks.delete(:read_raw)
+          @callback_mutex.unlock
+          @reading_raw = false
+          data
+        else
+          return_value = super(data)
+          @reading_normally = false
+          return_value
+        end
+      end
+
+      #
+      # Delegates to #_read. Data passes through #pre_callback_filter, runs all
+      # callbacks, and @state is set. BLOCKS calling thread.
       #
       def read(*args, **kwargs, &block)
         read_using(self.method(:_read), *args, **kwargs, &block)
       end
 
+      #
+      # Delegates to #_read. Data passes through #pre_callback_filter, runs all
+      # callbacks, and @state is set. DOES NOT BLOCK calling thread.
+      #
+      def read_nb(*args, **kwargs, &block)
+        @reader_mutex.lock
+        sleep READ_WAIT_TIME while read_busy?
+        @reading_normally = true
+        _read(*args, **kwargs, &block)
+        @reader_mutex.unlock
+      end
+
+      #
+      # NEVER call this directly. Use #read_nb instead.
+      #
+      # Define #_read in including class to get data which updates the
+      # peripheral state. See #read_using comments for more info.
+      #
+      def _read
+        raise NotImplementedError.new("#{self.class.name}#_read is not defined.")
+      end
+
       #
       # 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.
+      #
+      # Data is received when the board/bus calls #update on us. If a read was
+      # started by this method, the data will pass through #pre_callback_filter,
+      # trigger all callbacks, and set @state. Use this for reading the state
+      # of peripherals, like digital pin level, enviro sensor reading etc.
       #
       def read_using(reader, *args, **kwargs, &block)
-        add_callback(:read, &block) if block_given?
+        # Lock, THEN wait for other normal reads to finish.
+        @reader_mutex.lock
+        sleep READ_WAIT_TIME while read_busy?
+        @reading_normally = true
 
+        # One-time callbacks.
         return_value = nil
-        add_callback(:read) do |filtered_data|
-          return_value = filtered_data
-        end
-        
+        add_callback(:read) { |filtered_data| return_value = filtered_data }
+        add_callback(:read, &block) if block_given?
+
         reader.call(*args, **kwargs)
-        wait_for_read
+        @reader_mutex.unlock
 
+        # Wait for #update to remove the :read callbacks (return_value is set).
+        sleep READ_WAIT_TIME while callbacks[:read]
         return_value
       end
-      
-      def wait_for_read
-        loop do
-          break if !callbacks[:read]
-          sleep 0.001
-        end
+
+      #
+      # Similar to #read_using, but does not trigger #pre_callback_filter,
+      # or run any callbacks except :read_raw. BLOCKS calling thread.
+      # Use for things like sensor status, config etc.
+      #
+      def read_raw(reader, *args, **kwargs)
+        # Can't guarantee read order.
+        raise StandardError, "#read_raw unavailable while listening" if @listening
+
+        # Lock, THEN wait for any normal read to finish.
+        @reader_mutex.lock
+        sleep READ_WAIT_TIME while read_busy?
+        @reading_raw = true
+
+        # Special :read_raw one-time callback.
+        return_value = nil
+        add_callback(:read_raw) { |bytes| return_value = bytes }
+
+        # Call reader, but block and keep the lock until :read_raw callback gets run.
+        reader.call(*args, **kwargs)
+        sleep READ_WAIT_TIME while callbacks[:read_raw]
+        @reader_mutex.unlock
+
+        return_value
       end
 
-      def _read
-        raise NotImplementedError
-          .new("#{self.class.name}#_read is not defined.")
+      def read_busy?
+        # mruby gets stuck waiting somewhere, but doesn't have threads
+        # so it can never really be busy.
+        !Denko.mruby? && (@reading_normally || @reading_raw)
       end
     end
   end

data/lib/denko/behaviors/single_pin.rb

@@ -3,13 +3,11 @@ module Denko
     module SinglePin
       include Component
       attr_reader :pin, :mode
-      
-      def mode=(mode)          
+
+      def mode=(mode)
         board.set_pin_mode(pin, mode)
         @mode = mode
       end
-      
-    protected
 
       def convert_pins(options={})
         raise ArgumentError, 'a pin is required for this component' unless options[:pin]

data/lib/denko/behaviors/state.rb

@@ -3,24 +3,29 @@ module Denko
     module State
       include Lifecycle
 
-      # Force state initialization.
+      # Force state and mutex initialization.
       after_initialize do
+        @state_mutex = Denko.gil? ? Denko::MutexStub.new : Mutex.new
         state
       end
 
-      def state_mutex
-        @state_mutex ||= Denko.cruby? ? Denko::MutexStub.new : Mutex.new
-        @state_mutex
-      end
-
-      def state
-        state_mutex.synchronize { @state }
-      end
-
-      protected
+      # mruby optimization. Bypass state_mutex for simple states.
+      if Denko.mruby?
+        attr_accessor :state
+      else
+        def state
+          @state_mutex.lock
+          value = @state
+          @state_mutex.unlock
+          value
+        end
 
-      def state=(value)
-        state_mutex.synchronize { @state = value }
+        def state=(value)
+          @state_mutex.lock
+          @state = value
+          @state_mutex.unlock
+          @state
+        end
       end
 
       def update_state(value)

data/lib/denko/behaviors/threaded.rb

@@ -11,39 +11,50 @@ module Denko
         end
       end
 
+      def mruby_thread_check
+        if Denko.mruby?
+          raise NotImplementedError, "threads unavailable in mruby "
+        end
+      end
+
       def self.included(base)
         base.extend ClassMethods
       end
 
       def threaded(&block)
+        mruby_thread_check
         stop_thread
         enable_interrupts unless interrupts_enabled
         @thread = Thread.new(&block)
       end
 
       def threaded_loop(&block)
+        mruby_thread_check
         threaded do
           loop(&block)
         end
       end
 
       def stop_thread
+        mruby_thread_check
         @thread.kill if @thread
       end
 
       def stop
-        stop_thread
-        super if defined?(super)
+        stop_thread unless Denko.mruby?
+        begin; super; rescue NoMethodError; end
       end
 
       def enable_interrupts
-        interrupts = self.class.class_eval('@@interrupts') rescue []
-        interrupts.each do |method_name|
-          standard_method = self.method(method_name)
+        unless Denko.mruby?
+          interrupts = self.class.class_eval('@@interrupts') rescue []
+          interrupts.each do |method_name|
+            standard_method = self.method(method_name)
 
-          singleton_class.send(:define_method, method_name) do |*args|
-            stop_thread unless (Thread.current == @thread)
-            standard_method.call(*args)
+            singleton_class.send(:define_method, method_name) do |*args|
+              stop_thread unless (Thread.current == @thread)
+              standard_method.call(*args)
+            end
           end
         end
 

data/lib/denko/behaviors.rb

@@ -1,27 +1,40 @@
-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"
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+BEHAVIORS_FILES = [
+  # Pin and component setup stuff
+  [:Lifecycle,  "lifecycle"],
+  [:State,      "state"],
+  [:Component,  "component"],
+  [:SinglePin,  "single_pin"],
+  [:InputPin,   "input_pin"],
+  [:OutputPin,  "output_pin"],
+  [:MultiPin,   "multi_pin"],
+
+  # Subcomponent stuff
+  [:Subcomponents,          "subcomponents"],
+  [:BusController,          "bus_controller"],
+  [:BusControllerAddressed, "bus_controller_addressed"],
+  [:BusPeripheral,          "bus_peripheral"],
+  [:BusPeripheralAddressed, "bus_peripheral_addressed"],
+  [:BoardProxy,             "board_proxy"],
 
-    # Subcomponent stuff
-    autoload :Subcomponents,          "#{__dir__}/behaviors/subcomponents"
-    autoload :BusController,          "#{__dir__}/behaviors/bus_controller"
-    autoload :BusControllerAddressed, "#{__dir__}/behaviors/bus_controller_addressed"
-    autoload :BusPeripheral,          "#{__dir__}/behaviors/bus_peripheral"
-    autoload :BusPeripheralAddressed, "#{__dir__}/behaviors/bus_peripheral_addressed"
-    autoload :BoardProxy,             "#{__dir__}/behaviors/board_proxy"
+  # Async stuff
+  [:Threaded,   "threaded"],
+  [:Callbacks,  "callbacks"],
+  [:Reader,     "reader"],
+  [:Poller,     "poller"],
+  [:Listener,   "listener"],
+]
 
-    # Async stuff
-    autoload :Threaded,   "#{__dir__}/behaviors/threaded"
-    autoload :Callbacks,  "#{__dir__}/behaviors/callbacks"
-    autoload :Reader,     "#{__dir__}/behaviors/reader"
-    autoload :Poller,     "#{__dir__}/behaviors/poller"
-    autoload :Listener,   "#{__dir__}/behaviors/listener"
+module Denko
+  module Behaviors
+    BEHAVIORS_FILES.each do |file|
+      file_path = "#{__dir__}/behaviors/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/board/eeprom.rb

@@ -11,7 +11,7 @@ module Denko
     # CMD = 8
     def eeprom_write(address, bytes)
       address = pack :uint16, address
-      bytes  = pack :uint8, bytes, min: 1, max: 128
+      bytes   = pack :uint8,  bytes
       write Message.encode  command: 8,
                             value: bytes.length,
                             aux_message: address + bytes

data/lib/denko/board/i2c.rb

@@ -26,7 +26,7 @@ module Denko
 
     # CMD = 34
     def i2c_write(i2c_index, address, bytes, frequency=100000, repeated_start=false)
-      bytes = [bytes] unless bytes.class == Array
+      bytes = [bytes].flatten 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).

data/lib/denko/board/i2c_bit_bang.rb

@@ -1,5 +1,9 @@
 module Denko
   class Board
+    def i2c_bb_setup(scl, sda)
+      # Stub method. Other implementations may call this.
+    end
+
     # CMD = 30
     def i2c_bb_search(scl, sda)
       write Message.encode command: 30,
@@ -9,15 +13,15 @@ module Denko
 
     # CMD = 31
     def i2c_bb_write(scl, sda, address, bytes, repeated_start=false)
-      bytes = [bytes] unless bytes.class == Array
-            
+      bytes = [bytes].flatten unless bytes.class == Array
+
       # Use top bit of address to select stop condition (1), or repated start (0).
       send_stop = repeated_start ? 0 : 1
-      
+
       write Message.encode  command:     31,
                             pin:         scl,
                             value:       sda,
-                            aux_message: pack(:uint8, 0x00) + 
+                            aux_message: pack(:uint8, 0x00) +
                                          pack(:uint8, address | (send_stop << 7)) +
                                          pack(:uint8, bytes.length) +
                                          pack(:uint8, bytes)
@@ -40,7 +44,7 @@ module Denko
       write Message.encode  command:      32,
                             pin:          scl,
                             value:        sda,
-                            aux_message:  pack(:uint8, 0x00) + 
+                            aux_message:  pack(:uint8, 0x00) +
                                           pack(:uint8, address | (send_stop << 7)) +
                                           pack(:uint8, read_length) +
                                           register_packed

data/lib/denko/board/map.rb

@@ -5,7 +5,7 @@ module Denko
     MAPS_FOLDER = File.join(Denko.root, "vendor/board-maps/yaml")
 
     attr_reader :map
-    
+
     def substitute_zero_pins
       ["SDA", "SCL", "MOSI", "MISO", "SCK", "SS"].each do |name|
         symbol      = name.to_sym
@@ -25,7 +25,7 @@ module Denko
     rescue
       raise StandardError, "error loading board map from file for board name: '#{board_name}'"
     end
-    
+
     def convert_pin(pin)
       # Convert non numerical strings to symbols.
       pin = pin.to_sym if (pin.class == String) && !(pin.match (/\A\d+\.*\d*/))
@@ -50,6 +50,10 @@ module Denko
       rescue
         raise ArgumentError, "error in pin: #{pin.inspect}"
       end
+
+      def pin_is_pwm?(pin)
+        false
+      end
     end
   end
 end

data/lib/denko/board/one_wire.rb

@@ -1,9 +1,9 @@
 module Denko
   class Board
-    def one_wire_reset(pin, value=0)
+    def one_wire_reset(pin, read_presence=false)
       write Message.encode  command: 41,
                             pin: pin,
-                            value: value
+                            value: read_presence ? 1 : 0
     end
 
     def one_wire_search(pin, branch_mask)
@@ -12,7 +12,7 @@ module Denko
                             aux_message: pack(:uint64, branch_mask, max: 8)
     end
 
-    def one_wire_write(pin, parasite_power, *data)
+    def one_wire_write(pin, parasite_power, data)
       bytes  = pack :uint8, data, min: 1, max: 127 # Should be 128 with 0 = 1.
 
       # Set high bit of length if the bus must drive high after write.