denko 0.13.0

data/lib/denko/behaviors/multi_pin.rb

@@ -0,0 +1,72 @@
+module Denko
+  module Behaviors
+    module MultiPin
+      #
+      # Model complex components, using multiple pins, by using proxy components
+      # with one pin each. 
+      #
+      include Component
+      attr_reader :pin, :pins, :proxies
+      
+      # Return a hash with the state of each proxy component.
+      def proxy_states
+        hash = {}
+        proxies.each_key do |key|
+          hash[key] = proxies[key].state if self.proxies[key]
+        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) }
+        pin_array = pins.values
+        raise ArgumentError, "duplicate pins in: #{pins.inspect}" unless pin_array == pin_array.uniq
+      end
+
+      #
+      # 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.
+      # 
+      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])          
+          self.proxies[name] = proxy
+          instance_variable_set("@#{name}", proxy)
+        end
+
+        # 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
+      # the pin, but not do anything with it.
+      #
+      def require_pin(name)
+        raise ArgumentError, "missing #{name.inspect} pin" unless self.pins[name]
+      end
+
+      def require_pins(*array)
+        [array].flatten.each { |name| require_pin(name) }
+      end
+      
+      private
+      
+      attr_writer :pins, :proxies
+    end
+  end
+end

data/lib/denko/behaviors/output_pin.rb

@@ -0,0 +1,13 @@
+module Denko
+  module Behaviors
+    module OutputPin
+      include SinglePin
+      protected
+
+      def initialize_pins(options={})
+        super(options)
+        self.mode = :output
+      end
+    end
+  end
+end

data/lib/denko/behaviors/poller.rb

@@ -0,0 +1,31 @@
+module Denko
+  module Behaviors
+    module Poller
+      include Reader
+      include Threaded
+      
+      def poll_using(method, interval, *args, &block)
+        unless [Integer, Float].include? interval.class
+          raise ArgumentError, "wrong interval given to #poll : #{interval.inspect}"
+        end
+
+        stop
+        add_callback(:poll, &block) if block_given?
+
+        threaded_loop do
+          method.call(*args)
+          sleep interval
+        end
+      end
+
+      def poll(interval, *args, &block)
+        poll_using(self.method(:_read), interval, *args, &block)
+      end
+
+      def stop
+        super if defined?(super)
+        remove_callbacks :poll
+      end
+    end
+  end
+end

data/lib/denko/behaviors/reader.rb

@@ -0,0 +1,49 @@
+module Denko
+  module Behaviors
+    module Reader
+      include Callbacks
+
+      #
+      # Defalt behavior for #read is to delegate to #_read.
+      # Define #_read in including classes.
+      #
+      def read(*args, **kwargs, &block)
+        read_using(self.method(:_read), *args, **kwargs, &block)
+      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.
+      #
+      # Give procs as methods to build more complex functionality for buses.
+      #
+      def read_using(method, *args, **kwargs, &block)
+        add_callback(:read, &block) if block_given?
+
+        value = nil
+        add_callback(:read) do |filtered_data|
+          value = filtered_data
+        end
+        
+        method.call(*args, **kwargs)
+        block_until_read
+
+        value
+      end
+      
+      def block_until_read
+        loop do
+          break if !callbacks[:read]
+          sleep 0.001
+        end
+      end
+
+      def _read
+        raise NotImplementedError
+          .new("#{self.class.name}#_read is not defined.")
+      end
+    end
+  end
+end

data/lib/denko/behaviors/single_pin.rb

@@ -0,0 +1,26 @@
+module Denko
+  module Behaviors
+    module SinglePin
+      include Component
+      attr_reader :pin, :mode
+      
+      def mode=(mode)          
+        board.set_pin_mode(pin, mode)
+        @mode = mode
+      end
+      
+    protected
+
+      attr_writer :pin
+
+      def convert_pins(options={})
+        raise ArgumentError, 'a pin is required for this component' unless options[:pin]
+        options[:pin] = board.convert_pin(options[:pin])
+      end
+
+      def initialize_pins(options={})
+        self.pin = options[:pin]
+      end
+    end
+  end
+end

data/lib/denko/behaviors/state.rb

@@ -0,0 +1,24 @@
+module Denko
+  module Behaviors
+    module State
+      def initialize(options={})
+        @state_mutex = Mutex.new
+        @state = nil
+      end
+      
+      def state
+        @state_mutex.synchronize { @state }
+      end
+      
+      protected
+
+      def state=(value)
+        @state_mutex.synchronize { @state = value }
+      end
+      
+      def update_state(value)
+        self.state = value if value
+      end
+    end
+  end
+end

data/lib/denko/behaviors/subcomponents.rb

@@ -0,0 +1,35 @@
+module Denko
+  module Behaviors
+    module Subcomponents
+      def components
+        @components ||= []
+      end
+
+      def single_pin_components
+        @single_pin_components ||= {}
+      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
+          else
+            raise StandardError,  "Error adding #{component} to #{self}. Pin: #{component.pin} " \
+                                  "already in use by: #{single_pin_components[component.pin]}"
+          end
+        end
+      end
+
+      def remove_component(component)
+        if component.respond_to?(:pin) && component.pin.class == Integer
+          single_pin_components[component.pin] = nil
+        end
+        
+        deleted = components.delete(component)
+        component.stop if deleted && component.respond_to?(:stop)
+      end
+    end
+  end
+end

data/lib/denko/behaviors/threaded.rb

@@ -0,0 +1,54 @@
+module Denko
+  module Behaviors
+    module Threaded
+      attr_reader :thread, :interrupts_enabled
+
+      module ClassMethods
+        def interrupt_with(*args)
+          interrupts = self.class_eval('@@interrupts') rescue []
+          interrupts = (interrupts + args).uniq
+          self.class_variable_set(:@@interrupts, interrupts)
+        end
+      end
+
+      def self.included(base)
+        base.extend ClassMethods
+      end
+
+      def threaded(&block)
+        stop_thread
+        enable_interrupts unless interrupts_enabled
+        @thread = Thread.new(&block)
+      end
+
+      def threaded_loop(&block)
+        threaded do
+          loop(&block)
+        end
+      end
+
+      def stop_thread
+        @thread.kill if @thread
+      end
+
+      def stop
+        stop_thread
+        super if defined?(super)
+      end
+
+      def enable_interrupts
+        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)
+          end
+        end
+
+        @interrupts_enabled = true
+      end
+    end
+  end
+end

data/lib/denko/behaviors.rb

@@ -0,0 +1,26 @@
+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"
+  end
+end

data/lib/denko/board/core.rb

@@ -0,0 +1,151 @@
+module Denko
+  class Board
+    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
+    }
+
+    # CMD = 0
+    def set_pin_mode(pin, mode=:input)
+      unless PIN_MODES.keys.include? mode
+        raise ArgumentError, "cannot set mode: #{mode}. Should be one of: #{PIN_MODES.keys.inspect}"
+      end
+      write Message.encode  command: 0,
+                            pin: pin,
+                            value: PIN_MODES[mode]
+    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" 
+      end
+      write Message.encode command: 1, pin: pin, value: value
+    end
+
+    # CMD = 2
+    def digital_read(pin)
+      write Message.encode command: 2, pin: pin
+    end
+
+    # 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
+      write Message.encode command: 3, pin: pin, value: value.round
+    end
+    
+    # CMD = 4
+    def dac_write(pin,value)
+      if (value < 0) || (value > dac_high)
+        raise ArgumentError, "cannot write DAC value: #{value}. Should be Integer in range 0..#{dac_high} "
+      end
+      write Message.encode command: 4, pin: pin, value: value.round
+    end
+
+    # CMD = 5
+    def analog_read(pin, negative_pin=nil, gain=nil, sample_rate=nil)
+      write Message.encode command: 5, pin: pin
+    end
+
+    # CMD = 6
+    def set_listener(pin, state=:off, **options)
+      # Default to digital listener and validate.
+      options[:mode] ||= :digital
+      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
+
+      # Default to 4ms divider if digital, 16ms if analog.
+      if options[:mode] == :digital
+        options[:divider] ||= 4
+      else
+        options[:divider] ||= 16
+      end
+      
+      # Convert divider to exponent and validate.
+      exponent = Math.log2(options[:divider]).round
+      if (exponent < 0) || (exponent > 7)
+        raise ArgumentError, "error in divider: #{options[:divider]}. Should be one of: #{DIVIDERS.inspect}"
+      end
+
+      # Validate state.
+      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
+
+      # Send it.
+      write Message.encode  command: 6,
+                            pin: pin,
+                            value: state_byte,
+                            aux_message: pack(:uint8, [mode_byte, exponent])
+    end
+
+    # Convenience methods that wrap set_listener.
+    def digital_listen(pin, divider=4)
+      set_listener(pin, :on, mode: :digital, divider: divider)
+    end
+
+    def analog_listen(pin, divider=16)
+      set_listener(pin, :on, mode: :analog, divider: divider)
+    end
+
+    def stop_listener(pin)
+      set_listener(pin, :off)
+    end
+
+    # CMD = 92
+    #
+    # For diagnostics and testing mostly. What this does:
+    # 1) Tell the Connection to halt transmission immediately, after this message.
+    # 2) The board will send back a ready signal, which the Connection should read and resume transmisison.
+    #
+    # See comments on Board#write_and_halt for more info and use case.
+    #
+    def halt_resume_check
+      write_and_halt Message.encode command: 92
+    end
+
+    # CMD = 95
+    def set_register_divider(value)
+      unless DIVIDERS.include?(value)
+        raise ArgumentError, "error in divider: #{options[:divider]}. Should be one of: #{DIVIDERS.inspect}"
+      end
+      write Message.encode(command: 95, value: value)
+    end
+
+    # CMD = 96
+    def set_analog_write_resolution(value)
+      if (value < 0) || (value > 16)
+        raise ArgumentError, "cannot set resolution: #{value}. Should be Integer in range 0..16"
+      end
+      write Message.encode(command: 96, value: value)
+    end
+    
+    # CMD = 97
+    def set_analog_read_resolution(value)
+      if (value < 0) || (value > 16)
+        raise ArgumentError, "cannot set resolution: #{value}. Should be Integer in range 0..16"
+      end
+      write Message.encode(command: 97, value: value)
+    end
+
+    # CMD = 99
+    def micro_delay(duration)
+      if (duration < 0) || (duration > 0xFFFF)
+        raise ArgumentError, "error in duration: #{duration}. Should be Integer in range 0..65535"
+      end
+      write Message.encode command: 99, aux_message: pack(:uint16, [duration])
+    end
+  end
+end

data/lib/denko/board/eeprom.rb

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

data/lib/denko/board/i2c.rb

@@ -0,0 +1,68 @@
+module Denko
+  class Board
+    I2C_FREQUENCIES = {
+      100000  => 0x00,
+      400000  => 0x01,
+      1000000 => 0x02,
+      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
+
+    def i2c_convert_frequency(freq)
+      # Default to 100 kHz.
+      freq = 100000 unless freq
+
+      unless I2C_FREQUENCIES.include?(freq)
+        raise ArgumentError, "I2C frequency must be in: #{I2C_FREQUENCIES.keys.inspect}" 
+      end
+      I2C_FREQUENCIES[freq]
+    end
+
+    # CMD = 33
+    def i2c_search
+      write Message.encode command: 33
+    end
+
+    # CMD = 34
+    def i2c_write(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)
+    end
+
+    # CMD = 35
+    def i2c_read(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
+        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:      35,
+                            pin:          address | (send_stop << 7),
+                            value:        read_length,
+                            aux_message:  pack(:uint8, frequency) + register_packed
+    end
+  end
+end

data/lib/denko/board/infrared.rb

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

data/lib/denko/board/led_array.rb

@@ -0,0 +1,18 @@
+module Denko
+  class Board
+    def show_ws2812(pin, pixel_buffer)
+      length = pixel_buffer.length
+
+      # Settings are blank for now.
+      settings = pack :uint8, [0, 0, 0, 0]
+      
+      # Limit to 100 pixels (3-bytes each) for now
+      packed_pixels = pack :uint8, pixel_buffer, max: 300
+
+      write_and_halt Message.encode command: 19,
+                                    pin: pin,
+                                    value: length,
+                                    aux_message: settings + packed_pixels
+    end
+  end
+end

data/lib/denko/board/map.rb

@@ -0,0 +1,46 @@
+require 'yaml'
+
+module Denko
+  class Board
+    MAPS_FOLDER = File.join(Denko.root, "vendor/board-maps/yaml")
+
+    attr_reader :map
+    
+    def load_map(board_name)
+      if board_name
+        map_path = File.join(MAPS_FOLDER, "#{board_name}.yml")
+        @map = YAML.load_file(map_path)
+      else
+        @map = nil
+      end
+    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*/))
+
+      # Handle symbols.
+      if (pin.class == Symbol)
+        if map && map[pin]
+          return map[pin]
+        elsif map
+          raise ArgumentError, "error in pin: #{pin.inspect}. Make sure that pin is defined for this board by calling Board#map"
+        else
+          raise ArgumentError, "error in pin: #{pin.inspect}. Given a Symbol, but board has no map. Try using GPIO integer instead"
+        end
+      end
+
+      # Handle integers.
+      return pin if pin.class == Integer
+
+      # Try #to_i on anyting else. Will catch numerical strings.
+      begin
+        return pin.to_i
+      rescue
+        raise ArgumentError, "error in pin: #{pin.inspect}"
+      end
+    end
+  end
+end

data/lib/denko/board/message_pack.rb

@@ -0,0 +1,7 @@
+module Denko
+  class Board
+    def pack(*args, **kwargs)
+      Message.pack(*args, **kwargs)
+    end
+  end
+end