denko 0.13.6 → 0.15.0

data/lib/denko/display/st7565.rb

@@ -0,0 +1,166 @@
+module Denko
+  module Display
+    class ST7565
+      include Behaviors::Lifecycle
+      include SPICommon
+
+      COLUMNS = 128
+      ROWS    = 64
+
+      # Overall commands
+      RESET                 = 0b11100010
+      DISPLAY_ON            = 0b10101111
+      DISPLAY_OFF           = 0b10101110
+      ALL_POINTS_OFF        = 0b10100100
+      ALL_POINTS_ON         = 0b10100100
+      STATIC_INDICATOR_OFF  = 0b10101100
+      STATIC_INDICATOR_ON   = 0b10101101
+
+      def standby
+        command [DISPLAY_OFF, ALL_POINTS_ON]
+      end
+
+      def slp
+        command [STATIC_INDICATOR_OFF, 0b00, DISPLAY_OFF, ALL_POINTS_ON]
+      end
+
+      def wake
+        # Note static indicator stays disabled. Not sure how to use it.
+        command [ALL_POINTS_OFF, DISPLAY_ON, STATIC_INDICATOR_OFF, 0b00]
+      end
+
+      # Overall votage commands
+      POWER_CONTROL         = 0b00101000
+      LCD_BIAS_1_7          = 0b10100011
+      VOLUME                = 0b10000001
+      VALID_VOLUMES         = (0..63).to_a
+      #
+      # Control voltage regulator circuit. Values 0-7 are OR'ed into last 3 bits.
+      # 5 seems to work best for non-inverted mode, and 6 for inverted.
+      RESISTOR_RATIO        = 0b00100000
+      VALID_RESISTOR_RATIOS = (0..7).to_a
+
+      def resistor_ratio=(ratio)
+        raise ArgumentError, "invalid resistor ratio #{ratio}" unless VALID_RESISTOR_RATIOS.include? ratio
+        command [RESISTOR_RATIO | ratio]
+      end
+
+      def volume=(value)
+        raise ArgumentError, "invalid volume #{value}" unless VALID_VOLUMES.include? value
+        command [VOLUME, value]
+      end
+
+      #
+      # Addressing and writing to display RAM.
+      # Always in write mode. Called Read-Modify-Write and END in datasheet.
+      RMW_WRITE = 0b11100000
+      RMW_END   = 0b11101110
+      #
+      # Set page and column to start on before writing data.
+      # Page and column nibbles are OR'ed into lower 4 bits.
+      PASET       = 0b10110000
+      CASET_UPPER = 0b00010000
+      CASET_LOWER = 0b00000000
+      #
+      # Control X and Y mirroring, so the display can be reflected
+      # in either axis, or rotated 180 degrees, in hardware.
+      #
+      # How RAM columns map to pixels. Called ADC in datasheet.
+      COL_NORMAL  = 0b10100000
+      COL_REVERSE = 0b10100001
+      # How RAM pages map to pixels. Called Common Output Mode in datasheet.
+      PAGE_NORMAL  = 0b11000000
+      PAGE_REVERSE = 0b11001000
+      # RAM has 132 columns. Need to start at index 4 when columns get reversed.
+      COL_REVERSE_COL_START = 4
+
+      def x_ram_offset
+        @x_ram_offset ||= 0
+      end
+
+      def reflect_x
+        @reflected_x ||= false
+        @reflected_x ? command([COL_NORMAL]) : command([COL_REVERSE])
+        @reflected_x = !@reflected_x
+        @x_ram_offset = @reflected_x ? COL_REVERSE_COL_START : 0
+      end
+
+      def reflect_y
+        @reflected_y ||= false
+        @reflected_y ? command([PAGE_NORMAL]) : command([PAGE_REVERSE])
+        @reflected_y = !@reflected_y
+      end
+
+      def rotate
+        reflect_x
+        reflect_y
+      end
+
+      # Control display inversion.
+      # White on black is OFF. Black on white ON.
+      INVERT_OFF = 0b10100110
+      INVERT_ON  = 0b10100111
+
+      def invert
+        @inverted ||= false
+        if @inverted
+          command [INVERT_OFF]
+          self.resistor_ratio = 5
+        else
+          command [INVERT_ON]
+          self.resistor_ratio = 6
+        end
+        @inverted = !@inverted
+      end
+
+      after_initialize do
+        # Reset sequence.
+        reset.low if reset
+        sleep 0.001
+        reset.high if reset
+        command [RESET]
+
+        # Enable all power circuits:
+        # bit0 = voltage follower
+        # bit1 = voltage regulator
+        # bit2 = voltage booster
+        command [POWER_CONTROL | 0b111]
+        sleep 0.010
+
+        # Set LCD voltage bias ratio
+        command [LCD_BIAS_1_7]
+
+        # Non-inverted display by default. Set resistor ratio and volume.
+        self.resistor_ratio = 5
+        self.volume = 16
+
+        # Columns need to be reversed by default.
+        reflect_x
+        rotate if params[:rotated]
+
+        wake
+      end
+
+      def draw_partial(buffer, x_start, x_finish, p_start, p_finish, color=1)
+        x = x_start + x_ram_offset
+        x_lower4 = (x & 0b00001111)
+        x_upper4 = (x & 0b11110000) >> 4
+
+        (p_start..p_finish).each do |page|
+          command [RMW_WRITE]
+          # Set start page and column.
+          command [PASET | page, CASET_LOWER | x_lower4, CASET_UPPER | x_upper4]
+
+          # Get needed bytes for this page only.
+          src_start       = (columns * page) + x_start
+          src_end         = (columns * page) + x_finish
+          partial_buffer  = buffer[src_start..src_end]
+
+          # Send in chunks up to maximum transfer size.
+          partial_buffer.each_slice(transfer_limit) { |slice| data(slice) }
+          command [RMW_END]
+        end
+      end
+    end
+  end
+end

data/lib/denko/display.rb

@@ -1,7 +1,44 @@
+require_relative "display/font"
+
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+DISPLAY_FILES = [
+  # Character Displays
+  [:HD44780, "hd44780"],
+
+  # Pixel display mixins and helpers
+  [:PixelCommon,      "pixel_common"],
+  [:SPICommon,        "spi_common"],
+  [:SPIEPaperCommon,  "spi_epaper_common"],
+  [:Canvas,           "canvas"],
+
+  # OLEDs
+  [:MonoOLED, "mono_oled"],
+  [:SSD1306,  "ssd1306"],
+  [:SH1106,   "sh1106"],
+  [:SH1107,   "sh1107"],
+
+  # LCDs
+  [:PCD8544,  "pcd8544"],
+  [:ST7302,   "st7302"],
+  [:ST7565,   "st7565"],
+
+  # E-paper
+  [:IL0373,   "il0373"],
+  [:SSD168X,  "ssd168x"],
+  [:SSD1680,  "ssd1680"],
+  [:SSD1681,  "ssd1681"],
+]
+
 module Denko
   module Display
-    autoload :Canvas,   "#{__dir__}/display/canvas"
-    autoload :HD44780,  "#{__dir__}/display/hd44780"
-    autoload :SSD1306,  "#{__dir__}/display/ssd1306"
+    DISPLAY_FILES.each do |file|
+      file_path = "#{__dir__}/display/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/eeprom/at24c.rb

@@ -0,0 +1,67 @@
+module Denko
+  module EEPROM
+    class AT24C
+      include I2C::Peripheral
+
+      I2C_ADDRESS     = 0x50
+      I2C_FREQUENCY   = 400_000
+      READ_WRITE_US   = 20_000
+      WRITE_PAGE_SIZE = 64
+
+      def int_to_reg_array(int)
+        [ (int >> 8) & 0xFF, int & 0xFF ]
+      end
+
+      def [](loc)
+        if loc.class == Range
+          index  = loc.first
+          count  = loc.count
+          limit  = bus.board.i2c_limit
+          result = []
+
+          # Chunked reads based on Board#i2c_limit.
+          # Reading appears to cross page borders seamlessly.
+          while count > 0
+            this_count = (count > limit) ? limit : count
+            result += i2c_read_raw(this_count, register: int_to_reg_array(index))
+            index = index + this_count
+            count = count - this_count
+          end
+
+          result
+        else
+          i2c_read_raw(1, register: int_to_reg_array(loc))
+        end
+      end
+
+      def []=(loc, value)
+        if value.class == Array
+          # Start address uses up 2 bytes.
+          limit = bus.board.i2c_limit - 2
+
+          remaining = value.length
+          src_start = 0
+          dst_start = loc
+
+          while remaining > 0
+            # Limit to lowest of: remaining page size, I2C max size, or remaining bytes.
+            size = WRITE_PAGE_SIZE - (dst_start % WRITE_PAGE_SIZE)
+            size = limit if (limit < size)
+            size = remaining if (remaining < size)
+            src_end = src_start + size - 1
+
+            i2c_write(int_to_reg_array(dst_start) + value[src_start..src_end])
+            micro_delay(READ_WRITE_US)
+
+            remaining -= size
+            src_start += size
+            dst_start += size
+          end
+        else
+          i2c_write(int_to_reg_array(loc) + [value])
+          micro_delay(READ_WRITE_US)
+        end
+      end
+    end
+  end
+end

data/lib/denko/eeprom/board.rb

@@ -0,0 +1,69 @@
+module Denko
+  module EEPROM
+    class Board
+      include Behaviors::Component
+      include Behaviors::Reader
+
+      def max_eeperom_txn
+        @max_eeeprom_txn ||= board.aux_limit - 3
+      end
+
+      def length
+        board.eeprom_length
+      end
+
+      def pin
+        254
+      end
+
+      def [](loc)
+        if loc.class == Range
+          index     = loc.first
+          remaining = loc.count
+          result    = []
+
+          while remaining > 0
+            size = (max_eeperom_txn < remaining) ? max_eeperom_txn : remaining
+            end_address = index + size - 1
+            raise ArgumentError, "EEPROM address #{end_address} out of range" if (end_address >= length)
+
+            result    += read_using -> { board.eeprom_read(index, size) }
+            index     += size
+            remaining -= size
+          end
+          result
+        else
+          bytes = read_using -> { board.eeprom_read(loc, 1) }
+          bytes[0]
+        end
+      end
+
+      def []=(loc, value)
+        if value.class == Array
+          remaining = value.length
+          src_start = 0
+          dst_start = loc
+
+          while remaining > 0
+            size = (max_eeperom_txn < remaining) ? max_eeperom_txn : remaining
+            src_end = src_start + size - 1
+            raise ArgumentError, "EEPROM address #{src_end} out of range" if (src_end >= length)
+
+            board.eeprom_write(dst_start, value[src_start..src_end])
+
+            remaining -= size
+            src_start += size
+            dst_start += size
+          end
+        else
+          board.eeprom_write(loc, [value])
+        end
+      end
+
+      def pre_callback_filter(message)
+        # address = message.split("-", 2)[0].to_i
+        bytes = message.split("-", 2)[1].split(",").map(&:to_i)
+      end
+    end
+  end
+end

data/lib/denko/eeprom.rb

@@ -1,5 +1,19 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+EEPROM_FILES = [
+  [:Board,  "board"],
+  [:AT24C,  "at24c"],
+]
+
 module Denko
   module EEPROM
-    autoload :BuiltIn, "#{__dir__}/eeprom/built_in"
+    EEPROM_FILES.each do |file|
+      file_path = "#{__dir__}/eeprom/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end

data/lib/denko/helpers/engine_check.rb

@@ -0,0 +1,13 @@
+module Denko
+  def self.gil?
+    ["mruby", "ruby"].include? RUBY_ENGINE
+  end
+
+  def self.mruby?
+    RUBY_ENGINE == "mruby"
+  end
+
+  def self.in_mruby_build?
+    defined?(MRuby::Build)
+  end
+end

data/lib/denko/helpers/mutex_stub.rb

@@ -0,0 +1,13 @@
+module Denko
+  class MutexStub
+    def synchronize(&block)
+      block.call
+    end
+
+    def lock
+    end
+
+    def unlock
+    end
+  end
+end

data/lib/denko/helpers.rb

@@ -0,0 +1,6 @@
+HELPER_FILES = [
+  [nil, "engine_check"],
+  [nil, "mutex_stub"],
+]
+
+HELPER_FILES.each { |f| require_relative "helpers/#{f[1]}"}

data/lib/denko/i2c/bit_bang.rb

@@ -0,0 +1,32 @@
+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) }
+        board.i2c_bb_setup(pins[:scl], pins[:sda])
+      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,50 @@
+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
+
+      def search
+        addresses = read_using -> { _search }
+        if addresses.class == String
+          @found_devices = addresses.split(":").map(&:to_i).reject{ |e| e==0 }
+        elsif addresses.class == Array
+          # 0th element being 0 (invalid address) means the array contains search results,
+          # instead of bytes read from a peripheral. Remove it.
+          @found_devices = addresses - [0]
+        end
+      end
+
+      def bubble_callbacks
+        add_callback(:bus_controller) do |data|
+          bytes = nil
+
+          # Array data from PiBoard.
+          if data.class == Array
+            address = data[0]
+            bytes = data[1..-1]
+
+          # 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,48 @@ 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(num_bytes, register: nil)
+        bus.read_nb(i2c_address, register, num_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_raw(num_bytes, register: nil)
+        read_raw -> { bus.read_nb(i2c_address, register, num_bytes, i2c_frequency, i2c_repeated_start)}
       end
     end
   end

data/lib/denko/i2c.rb

@@ -1,6 +1,21 @@
+# Represent files to be autoloaded in CRuby as an Array.
+# This allows Mruby::Build to parse and preload them instead.
+I2C_FILES = [
+  [:BusCommon,  "bus_common"],
+  [:Bus,        "bus"],
+  [:BitBang,    "bit_bang"],
+  [:Peripheral, "peripheral"],
+]
+
 module Denko
   module I2C
-    autoload :Bus,        "#{__dir__}/i2c/bus"
-    autoload :Peripheral, "#{__dir__}/i2c/peripheral"
+    I2C_FILES.each do |file|
+      file_path = "#{__dir__}/i2c/#{file[1]}"
+      if file[0]
+        autoload file[0], file_path
+      else
+        require file_path
+      end
+    end
   end
 end