denko 0.13.6 → 0.15.0

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]
@@ -18,6 +16,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,33 @@
 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
-      end
-      
-      def state
-        @state_mutex.synchronize { @state }
+      include Lifecycle
+
+      # Force state and mutex initialization.
+      after_initialize do
+        @state_mutex = Denko.gil? ? Denko::MutexStub.new : Mutex.new
+        state
       end
-      
-      protected
 
-      def state=(value)
-        @state_mutex.synchronize { @state = value }
+      # 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.lock
+          @state = value
+          @state_mutex.unlock
+          @state
+        end
       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/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,26 +1,40 @@
+# 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"],
+
+  # Async stuff
+  [:Threaded,   "threaded"],
+  [:Callbacks,  "callbacks"],
+  [:Reader,     "reader"],
+  [:Poller,     "poller"],
+  [:Listener,   "listener"],
+]
+
 module Denko
   module Behaviors
-    # Pin and component setup stuff
-    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"
-    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
-    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"
+    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/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/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

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

data/lib/denko/board/i2c_bit_bang.rb

@@ -0,0 +1,53 @@
+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,
+                           pin:     scl,
+                           value:   sda
+    end
+
+    # CMD = 31
+    def i2c_bb_write(scl, sda, address, bytes, repeated_start=false)
+      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) +
+                                         pack(:uint8, address | (send_stop << 7)) +
+                                         pack(:uint8, bytes.length) +
+                                         pack(:uint8, bytes)
+    end
+
+    # CMD = 32
+    def i2c_bb_read(scl, sda, address, register, read_length, repeated_start=false)
+      # Use top bit of address to select stop condition (1), or repated start (0).
+      send_stop = repeated_start ? 0 : 1
+
+      # A register address starting register address can be given (up to 4 bytes)
+      if register
+        register = [register].flatten
+        raise ArgumentError, 'maximum 4 byte register address for I2C read' if register.length > 4
+        register_packed = pack(:uint8, [register.length] + register)
+      else
+        register_packed = pack(:uint8, [0])
+      end
+
+      write Message.encode  command:      32,
+                            pin:          scl,
+                            value:        sda,
+                            aux_message:  pack(:uint8, 0x00) +
+                                          pack(:uint8, address | (send_stop << 7)) +
+                                          pack(:uint8, read_length) +
+                                          register_packed
+    end
+  end
+end

data/lib/denko/board/infrared.rb

@@ -2,17 +2,17 @@ module Denko
   class Board
     def infrared_emit(pin, frequency, pulses)
       #
-      # Limit to 255 marks/spaces (not pairs) for now.
+      # Limit to 255 marks/spaces (not pairs).
       #
-      # Length must be 1-byte long, not literally 1
+      # Make length uint16 as well, for aligned memory access on ESP8266.
       # Pulses max is 2x255 bytes long since each is 2 bytes.
-      length = pack :uint8,  pulses.length,  max: 1
+      length = pack :uint16, pulses.length,  max: 2
       bytes  = pack :uint16, pulses, min: 1, max: 510
 
       write Message.encode command: 16,
-                          pin: pin,
-                          value: frequency,
-                          aux_message: length + bytes
+                           pin: pin,
+                           value: frequency,
+                           aux_message: length + bytes
     end
   end
 end

data/lib/denko/board/led_array.rb

@@ -1,15 +1,16 @@
 module Denko
   class Board
     def show_ws2812(pin, pixel_buffer)
-      # Settings are blank for now.
-      settings = pack :uint8, [0, 0, 0, 0]
-      
-      packed_pixels = pack :uint8, pixel_buffer
+      # ALWAYS have first 4 bytes set to 0. ESP32 crashes without this!
+      # Last 4 bytes will be settings, but not yet. Just 24-bit 800 kHz for now.
+      settings    = pack :uint8, [0, 0, 0, 0, 0, 0, 0, 0]
+
+      pixel_bytes = pack :uint8, pixel_buffer
       
       write_and_halt Message.encode command: 19,
                                     pin: pin,
                                     value: pixel_buffer.length,
-                                    aux_message: settings + packed_pixels
+                                    aux_message: settings + pixel_bytes
     end
   end
 end

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.