denko 0.13.5 → 0.14.0

data/lib/denko/display/ssd1306.rb

@@ -3,7 +3,12 @@ require_relative 'canvas'
 module Denko
   module Display
     class SSD1306
-      include I2C::Peripheral
+      include Behaviors::BusPeripheral
+      include Behaviors::Lifecycle
+
+      # I2C Defaults
+        I2C_ADDRESS   = 0x3C
+        I2C_FREQUENCY = 400_000
 
       # Fundamental Commands
         # Single byte (no need to OR with anything)
@@ -27,9 +32,13 @@ module Denko
         PAGE_START         = 0xB0 # page 0-7
 
         # Double byte. Following byte sets value.
-        ADDRESSING_MODE    = 0x20
-          # Values: 0x00 = horizontal, 0x01 = vertical, 0x02 = page
-      
+        ADDRESSING_MODE  = 0x20
+          # Values:
+          #   0x00 = horizontal (Pages auto-increment. Used for SSD1306)
+          #   0x01 = vertical
+          #   0x02 = page       (Default. Page and column must be set each time. Needed on SH1106)
+        ADDRESSING_MODE_DEFAULT = 0x00
+
         # Triple byte. Following 2 bytes sets value. For H/V addressing modes only.
         COLUMN_ADDRESS_RANGE = 0x21
         PAGE_ADDRESS_RANGE   = 0x22
@@ -61,38 +70,59 @@ module Denko
       WIDTHS  = [64,96,128]
       HEIGHTS = [16,32,48,64]
 
-      def before_initialize(options={})
-        @i2c_address   = 0x3C
-        @i2c_frequency = 400000
-        super(options)
+      attr_accessor :canvas
+
+      # Default to a 128x64 display.
+      def columns
+        @columns ||= params[:columns] || params[:width] || 128
       end
 
-      def after_initialize(options={})
-        super(options)
+      def rows
+        @rows ||= params[:rows] || params[:height] || 64
+      end
 
-        # Default to a 128x64 display.
-        @columns = options[:columns] || options[:width]  || 128
-        @rows    = options[:rows]    || options[:height] || 64
+      def rotated
+        return @rotated unless @rotated.nil?
+        @rotated = params[:rotated]
+        @rotated = params[:rotate] if @rotated.nil?
+        @rotated = false if @rotated.nil?
+        @rotated
+      end
+
+      # Decide whether this instnace is I2C or SPI.
+      before_initialize do
+        bus = params[:bus] || params[:board]
 
+        if bus.class.ancestors.include?(Denko::SPI::Bus) || bus.class.ancestors.include?(Denko::SPI::BitBang)
+          mutate_spi
+        elsif bus.class.ancestors.include?(Denko::I2C::Bus) || bus.class.ancestors.include?(Denko::I2C::BitBang)
+          mutate_i2c
+        else
+          raise ArgumentError, "#{self.class} must be connected to either an I2C or SPI bus"
+        end
+      end
+
+      after_initialize do
         # Validate known sizes.
-        raise ArgumentError, "error in SSD1306 width: #{@columns}. Must be in: #{WIDTHS.inspect}" unless WIDTHS.include?(@columns)
-        raise ArgumentError, "error in SSD1306 height: #{@rows}. Must be in: #{HEIGHTS.inspect}" unless HEIGHTS.include?(@rows)
+        raise ArgumentError, "error in #{self.class} width: #{columns}. Must be in: #{WIDTHS.inspect}" unless WIDTHS.include?(columns)
+        raise ArgumentError, "error in #{self.class} height: #{rows}. Must be in: #{HEIGHTS.inspect}" unless HEIGHTS.include?(rows)
 
         # Everything except 96x16 size uses clock 0x80.
         clock = 0x80
-        clock = 0x60 if (@columns == 96 && @rows == 16)
+        clock = 0x60 if (columns == 96 && rows == 16)
 
         # 128x32 and 96x16 sizes use com pin config 0x02
         com_pin_config = 0x12
-        com_pin_config = 0x02 if (@columns == 96 && @rows == 16) || (@columns == 128 && @rows == 32)
+        com_pin_config = 0x02 if (columns == 96 && rows == 16) || (columns == 128 && rows == 32)
 
         # Reflecting horizontally and vertically to effectively rotate 180 degrees.
-        seg_remap     = options[:rotate] ? 0x01 : 0x00
-        com_direction = options[:rotate] ? 0x08 : 0x00
+        seg_remap     = rotated ? 0x01 : 0x00
+        com_direction = rotated ? 0x08 : 0x00
 
-        # Startup sequence
+        # Startup sequence (SPI doesn't work properly if this isn't sent twice.)
+        2.times do
         command [
-          MULTIPLEX_RATIO,        @rows - 1,
+          MULTIPLEX_RATIO,        rows - 1,
           DISPLAY_OFFSET,         0x00,
           START_LINE            | 0x00,
           SEGMENT_REMAP         | seg_remap,
@@ -104,23 +134,22 @@ module Denko
           VCOM_DESELECT_LEVEL,    0x20,
           PRECHARGE_PERIOD,       0xF1,           # Charge period for internal charge pump
           CHARGE_PUMP,            0x14,           # Internal charge pump
-          ADDRESSING_MODE,        0x00,           # Horizontal addressing mode so pages auto increment
+          ADDRESSING_MODE,        self.class::ADDRESSING_MODE_DEFAULT,
           DISPLAY_ON
         ]
-        
+        end
+
         # Create a new blank canvas and draw it.
-        self.canvas = Canvas.new(@columns, @rows)
+        self.canvas = Canvas.new(columns, rows)
         draw
       end
 
-      attr_accessor :canvas
-
       def off
-        command(DISPLAY_OFF)
+        command [DISPLAY_OFF]
       end
 
       def on
-        command(DISPLAY_ON)
+        command [DISPLAY_ON]
       end
 
       def contrast=(value)
@@ -128,24 +157,24 @@ module Denko
         command [CONTRAST, value]
       end
 
-      def draw(x_min=0, x_max=(@columns-1), y_min=0, y_max=(@rows-1))
+      def draw(x_min=0, x_max=(columns-1), y_min=0, y_max=(rows-1))
         # Convert y-coords to page coords.
         p_min = y_min / 8
         p_max = y_max / 8
-        
+
         # If drawing the whole frame (default), bypass temp buffer to save time.
-        if (x_min == 0) && (x_max == @columns-1) && (p_min == 0) && (p_max == @rows/8)
+        if (x_min == 0) && (x_max == columns-1) && (p_min == 0) && (p_max == rows/8)
           draw_partial(canvas.framebuffer, x_min, x_max, p_min, p_max)
-          
-        # Copy bytes for the given rectangle into a temp buffer. 
+
+        # Copy bytes for the given rectangle into a temp buffer.
         else
           temp_buffer = []
           (p_min..p_max).each do |page|
-            src_start = (@columns * page) + x_min
-            src_end   = (@columns * page) + x_max
+            src_start = (columns * page) + x_min
+            src_end   = (columns * page) + x_max
             temp_buffer += canvas.framebuffer[src_start..src_end]
           end
-    
+
           # And draw them.
           draw_partial(temp_buffer, x_min, x_max, p_min, p_max)
         end
@@ -154,25 +183,56 @@ module Denko
       def draw_partial(buffer, x_min, x_max, p_min, p_max)
         # Limit auto-incrementing GRAM address to the rectangle being drawn.
         command [ COLUMN_ADDRESS_RANGE, x_min, x_max, PAGE_ADDRESS_RANGE, p_min, p_max ]
-        
+
         # Send all the bytes at once if within board I2C limit.
         if buffer.length < (bus.board.i2c_limit - 1)
           data(buffer)
-        
+
         # Or split into chunks.
-        else  
+        else
           buffer.each_slice(bus.board.i2c_limit - 1) { |slice| data(slice) }
         end
       end
 
-      # Commands are I2C messages prefixed with 0x00.
-      def command(bytes)
-        i2c_write([0x00] + bytes)
+      def mutate_i2c
+        singleton_class.class_eval do
+          include I2C::Peripheral
+
+          # Commands are I2C messages prefixed with 0x00.
+          def command(bytes)
+            i2c_write([0x00] + bytes)
+          end
+
+          # Data are I2C messages prefixed with 0x40.
+          def data(bytes)
+            i2c_write([0x40] + bytes)
+          end
+        end
       end
 
-      # Data are I2C messages prefixed with 0x40.
-      def data(bytes)
-        i2c_write([0x40] + bytes)
+      def mutate_spi
+        singleton_class.class_eval do
+          include SPI::Peripheral::MultiPin
+
+          def initialize_pins(options={})
+            super(options)
+            proxy_pin :dc,    DigitalIO::Output, board: bus.board
+            proxy_pin :reset, DigitalIO::Output, board: bus.board, optional: true
+            reset.high if reset
+          end
+
+          # Commands are SPI bytes written while DC pin low.
+          def command(bytes)
+            dc.low
+            spi_write(bytes)
+          end
+
+          # Data are SPI SPI bytes written while DC pin high.
+          def data(bytes)
+            dc.high
+            spi_write(bytes)
+          end
+        end
       end
     end
   end

data/lib/denko/display.rb

@@ -3,5 +3,6 @@ module Denko
     autoload :Canvas,   "#{__dir__}/display/canvas"
     autoload :HD44780,  "#{__dir__}/display/hd44780"
     autoload :SSD1306,  "#{__dir__}/display/ssd1306"
+    autoload :SH1106,   "#{__dir__}/display/sh1106"
   end
 end

data/lib/denko/eeprom/built_in.rb

@@ -3,6 +3,7 @@ module Denko
     class BuiltIn
       include Behaviors::Component
       include Behaviors::Reader
+      include Behaviors::Lifecycle
 
       public :state=
 
@@ -10,12 +11,14 @@ module Denko
         254
       end
 
-      def after_initialize(options={})
-        super(options)
-        self.state = Array.new(board.eeprom_length, nil)
+      after_initialize do
         load
       end
 
+      def state
+        state_mutex.synchronize { @state ||= Array.new(board.eeprom_length, nil) }
+      end
+
       def load
         state.each_slice(128).with_index do |slice, index|
           read_using -> { board.eeprom_read(index * 128, slice.length) }
@@ -23,36 +26,36 @@ module Denko
       end
 
       def save
-        @state_mutex.synchronize do
+        state_mutex.synchronize do
           @state.each_slice(128).with_index do |slice, index|
             board.eeprom_write(index * 128, slice)
           end
         end
         load
       end
-      
+
       #
       # Specific Array-like methods for convenience.
-      # 
+      #
       def length; board.eeprom_length; end
       alias :count :length
-      
+
       def [](index)
-        @state_mutex.synchronize { @state.send :[], index }
+        state_mutex.synchronize { @state.send :[], index }
       end
-      
+
       def []=(index, value)
-        @state_mutex.synchronize { @state.send :[]=, index, value }
+        state_mutex.synchronize { @state.send :[]=, index, value }
       end
-      
+
       def each(&block)
-        @state_mutex.synchronize { @state.send :each, &block }
+        state_mutex.synchronize { @state.send :each, &block }
       end
-      
+
       def each_with_index(&block)
-        @state_mutex.synchronize { @state.send :each_with_index, &block }
+        state_mutex.synchronize { @state.send :each_with_index, &block }
       end
-      
+
       def pre_callback_filter(message)
         address = message.split("-", 2)[0].to_i
         bytes = message.split("-", 2)[1].split(",").map(&:to_i)
@@ -60,7 +63,7 @@ module Denko
       end
 
       def update_state(hash)
-        @state_mutex.synchronize do
+        state_mutex.synchronize do
           @state[hash[:address], hash[:data].length] = hash[:data]
         end
       end

data/lib/denko/i2c/bit_bang.rb

@@ -0,0 +1,31 @@
+module Denko
+  module I2C
+    class BitBang
+      include Behaviors::MultiPin
+      include Behaviors::Lifecycle
+      include BusCommon
+
+      def initialize_pins(options={})
+        proxy_pin :scl, DigitalIO::CBitBang
+        proxy_pin :sda, DigitalIO::CBitBang
+      end
+
+      after_initialize do
+        # Data received for the SDA pin is really for the bus.
+        sda.add_callback(:bus_forwarder) { |data| self.update(data) }
+      end
+
+      def _search
+        board.i2c_bb_search(pins[:scl], pins[:sda])
+      end
+
+      def write(address, bytes, frequency=nil, repeated_start=false)
+        board.i2c_bb_write(pins[:scl], pins[:sda], address, bytes, repeated_start)
+      end
+
+      def _read(address, register, num_bytes, frequency=nil, repeated_start=false)
+        board.i2c_bb_read(pins[:scl], pins[:sda], address, register, num_bytes, repeated_start)
+      end
+    end
+  end
+end

data/lib/denko/i2c/bus.rb

@@ -1,51 +1,23 @@
 module Denko
   module I2C
     class Bus
-      include Behaviors::SinglePin
-      include Behaviors::BusControllerAddressed
-      include Behaviors::Reader
+      include Behaviors::Lifecycle
+      include BusCommon
 
-      attr_reader :found_devices
-
-      def after_initialize(options={})
-        super(options)
-        @found_devices = []
-        bubble_callbacks
+      def i2c_index
+        @i2c_index ||= params[:i2c_index] || params[:index] || 0
       end
 
-      def search
-        addresses = read_using -> { board.i2c_search }
-        @found_devices = addresses.split(":").map(&:to_i) if addresses
+      def _search
+        board.i2c_search(i2c_index)
       end
 
       def write(address, bytes, frequency=100000, repeated_start=false)
-        board.i2c_write(address, bytes, frequency, repeated_start)
+        board.i2c_write(i2c_index, address, bytes, frequency, repeated_start)
       end
 
       def _read(address, register, num_bytes, frequency=100000, repeated_start=false)
-        board.i2c_read(address, register, num_bytes, frequency, repeated_start)
-      end
-      
-      def bubble_callbacks
-        add_callback(:bus_controller) do |str|
-          if str && str.match(/\A\d+-/)
-            address, data = str.split("-", 2)
-            address = address.to_i
-
-            data = data.split(",").map(&:to_i)
-            data = nil if data.empty?
-
-            update_component(address, data)
-          end
-        end
-      end
-
-      def update_component(address, data)
-        components.each do |component|
-          if component.address == address
-            component.update(data)
-          end
-        end
+        board.i2c_read(i2c_index, address, register, num_bytes, frequency, repeated_start)
       end
     end
   end

data/lib/denko/i2c/bus_common.rb

@@ -0,0 +1,45 @@
+module Denko
+  module I2C
+    module BusCommon
+      include Behaviors::BusControllerAddressed
+      include Behaviors::Reader
+      include Behaviors::Lifecycle
+
+      after_initialize do
+        bubble_callbacks
+      end
+
+      def found_devices
+        @found_devices ||= []
+      end
+      attr_writer :found_devices
+
+      def search
+        addresses = read_using -> { _search }
+        @found_devices = addresses.split(":").map(&:to_i).reject{ |e| e==0 } if addresses
+      end
+
+      def bubble_callbacks
+        add_callback(:bus_controller) do |data|
+          bytes = nil
+
+          # Array data from PiBoard.
+          if data.class == Array
+            address = data.shift
+            bytes = data
+
+          # String data from microcontroller.
+          elsif (data.class == String) && (data.match /\A\d+-/)
+            address, bytes = data.split("-", 2)
+            address = address.to_i
+            bytes = bytes.split(",").map(&:to_i)
+            bytes = nil if bytes.empty?
+          end
+
+          # Update components.
+          components.each { |c| c.update(bytes) if c.address == address } if bytes
+        end
+      end
+    end
+  end
+end

data/lib/denko/i2c/peripheral.rb

@@ -3,35 +3,44 @@ module Denko
     module Peripheral
       include Behaviors::BusPeripheralAddressed
       include Behaviors::Reader
+      include Behaviors::Lifecycle
 
-      def before_initialize(options={})
-        # Allow peripherals to set @i2c_address.
-        @address            ||= @i2c_address
+      # Set I2C defaults for including classes by defining these constants in them.
+      I2C_ADDRESS         = nil
+      I2C_FREQUENCY       = 100_000
+      I2C_REPEATED_START  = false
 
-        # I2C defaults if peripheral does not set.
-        @i2c_frequency      ||= 100000
-        @i2c_repeated_start ||= false
+      def i2c_default(sym)
+        const_sym = "I2C_#{sym}".upcase.to_sym
+        self.class.const_get(const_sym) if self.class.const_defined?(const_sym)
+      end
 
-        # Override defaults if given in options.
-        @i2c_frequency      = options[:i2c_frequency]      if options[:i2c_frequency]
-        @i2c_repeated_start = options[:i2c_repeated_start] if options[:i2c_frequency]
+       # Use @address instead of @i2c_address for default BusPeripheral behavior.
+      def address
+        @address ||= params[:i2c_address] || params[:address] || i2c_default(:address)
+      end
+      alias :i2c_address :address
 
-        # Allow generic :address option to be given as :i2c_address before validation.
-        # Superclass method will hande override.
-        options[:address] ||= options[:i2c_address]
+      def i2c_frequency
+        @i2c_frequency ||= params[:i2c_frequency] || params[:frequency] || i2c_default(:frequency)
+      end
 
-        super(options)
+      def i2c_repeated_start
+        return @i2c_repeated_start unless @i2c_repeated_start.nil?
+        @i2c_repeated_start = params[:i2c_repeated_start]   if @i2c_repeated_start.nil?
+        @i2c_repeated_start = params[:repeated_start]       if @i2c_repeated_start.nil?
+        @i2c_repeated_start = i2c_default(:repeated_start)  if @i2c_repeated_start.nil?
+        @i2c_repeated_start
       end
-      
-      attr_accessor :i2c_repeated_start, :i2c_frequency
-      alias :i2c_address :address
+
+      attr_writer :i2c_frequency, :i2c_repeated_start
 
       def i2c_write(bytes=[])
-        bus.write(address, bytes, i2c_frequency, i2c_repeated_start)
+        bus.write(i2c_address, bytes, i2c_frequency, i2c_repeated_start)
       end
 
-      def i2c_read(register, num_bytes)
-        bus._read(address, register, num_bytes, i2c_frequency, i2c_repeated_start)
+      def i2c_read(num_bytes, register: nil)
+        bus._read(i2c_address, register, num_bytes, i2c_frequency, i2c_repeated_start)
       end
     end
   end

data/lib/denko/i2c.rb

@@ -1,6 +1,8 @@
 module Denko
   module I2C
+    autoload :BusCommon,  "#{__dir__}/i2c/bus_common"
     autoload :Bus,        "#{__dir__}/i2c/bus"
+    autoload :BitBang,    "#{__dir__}/i2c/bit_bang"
     autoload :Peripheral, "#{__dir__}/i2c/peripheral"
   end
 end

data/lib/denko/led/apa102.rb

@@ -1,39 +1,52 @@
 module Denko
   module LED
     class APA102
-      include SPI::Peripheral
+      include Behaviors::BusPeripheral
+      include Behaviors::Lifecycle
 
-      attr_reader :length, :bpp, :brightness
+      def pin; nil; end
 
-      def before_initialize(options={})
-        options[:pin] = 255
-        super(options)
+      def length
+        @length ||= params[:length] || 1
       end
 
-      def after_initialize(options={})
-        super(options)
-
-        raise ArgumentError, "no length given for APA102 array" unless options[:length]
-        @length = options[:length]
+      # Start frame is always 32 0-bits (4 bytes).
+      def start_frame
+        @start_frame ||= Array.new(4) { 0 }
+      end
 
-        # Start frame is always 32 0-bits (4 bytes).
-        @start_frame = Array.new(4) { 0 }
+      def end_frame
+        return @end_frame if @end_frame
 
-        # End frame must be at least @length/2 bits long, and 32 bits (4 bytes) minimum.
-        end_frame_bytes = (@length / 16.0).ceil
+        # End frame must be at least length/2 bits long, and 32 bits (4 bytes) minimum.
+        end_frame_bytes = (length / 16.0).ceil
         end_frame_bytes = 4 if end_frame_bytes < 4
 
         # Use all 0's for end frame instead of 1's. Prevents extra pixel when using partial strip.
         @end_frame = Array.new(end_frame_bytes) { 0 }
+      end
 
-        # This is BYTES per pixel, not bits per pixel.
-        # 0th byte is per-pixel brightness (PWM applied to all 3 colors).
-        @bpp = 4
-        @buffer = Array.new(length * bpp) { 0 }
+      # This is BYTES per pixel, not bits per pixel.
+      # 0th byte is per-pixel brightness (PWM applied to all 3 colors).
+      def bpp
+        @bpp ||= 4
+      end
+
+      def buffer
+        @buffer ||= Array.new(length * bpp) { 0 }
+      end
 
+      attr_writer :buffer
+
+      before_initialize do
+        unless [Denko::SPI::Bus, Denko::SPI::BitBang].include? params[:bus].class
+          raise "APA102 must be connected to the output pin of a SPI bus"
+        end
+      end
+
+      after_initialize do
         # Default to max brightness.
         self.brightness = 31
-        
         off
       end
 
@@ -47,26 +60,26 @@ module Denko
         @masked_brightness = 0b11100000 | @brightness
 
         # Set brightness for all pixels.
-        (0..@length-1).each do |index|
-          @buffer[index*bpp+0] = @masked_brightness
+        (0..length-1).each do |index|
+          buffer[index*bpp+0] = @masked_brightness
         end
       end
 
       def []=(index, array)
         # Per-pixel brightness control, as optional 3rd indexed element of array.
         if array[3]
-          @buffer[index*bpp+0] = 0b11100000 | array[3]
+          buffer[index*bpp+0] = 0b11100000 | array[3]
         end
-        
+
         # APA102 uses BGR ordering.
-        @buffer[index*bpp+1] = array[2]
-        @buffer[index*bpp+2] = array[1]
-        @buffer[index*bpp+3] = array[0]
+        buffer[index*bpp+1] = array[2]
+        buffer[index*bpp+2] = array[1]
+        buffer[index*bpp+3] = array[0]
       end
 
       def all_on
         self.brightness = 31
-        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,255,255,255] }.flatten
+        self.buffer     = buffer.each_slice(bpp).map { [@masked_brightness,255,255,255] }.flatten
         show
       end
 
@@ -76,11 +89,12 @@ module Denko
       end
 
       def clear
-        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,0,0,0] }.flatten
+        self.buffer = buffer.each_slice(bpp).map { [@masked_brightness,0,0,0] }.flatten
       end
 
       def show
-        spi_write(@start_frame + @buffer + @end_frame)
+        data = start_frame + buffer + end_frame
+        bus.transfer(pin, write: data)
       end
     end
   end

data/lib/denko/led/base.rb

@@ -2,11 +2,17 @@ module Denko
   module LED
     class Base < PulseIO::PWMOutput
       def blink(interval=0.5)
-        threaded_loop do 
+        self.blink_interval = interval
+        threaded_loop do
           toggle
-          sleep interval
+          sleep @blink_interval
         end
       end
+
+      def blink_interval=(interval)
+        @blink_interval = interval
+      end
+      attr_reader :blink_interval
     end
   end
 end