denko 0.14.0 → 0.15.0

data/lib/denko/display/st7302.rb

@@ -0,0 +1,207 @@
+module Denko
+  module Display
+    class ST7302
+      include Behaviors::Lifecycle
+      include SPICommon
+
+      # Commands
+      SWRESET     = 0x01
+      DISPOFF     = 0x28
+      DISPON      = 0x29
+      OSC_EN      = 0xC7
+      BSTEN       = 0xD1
+      SLPIN       = 0x10
+      SLPOUT      = 0x11
+      HPM         = 0x38
+      LPM         = 0x39
+      NVMLOADEN   = 0xEB
+      NVMLOADCTRL = 0xD7
+      GCTRL       = 0xC0
+      SCTRL1      = 0xC1
+      SCTRL2      = 0xC2
+      VCOMCTRL    = 0xCB
+      GATEUPDEQ   = 0xB4
+      DUTYSET     = 0xB0
+      DTFORM      = 0x3A
+      SOCSET      = 0xB9
+      PNLSET      = 0xB8
+      MADCTL      = 0x36
+      CASET       = 0x2A
+      RASET       = 0x2B
+      INVOFF      = 0x20
+      INVON       = 0x21
+      FRCTRL      = 0xB2
+      RAMWR       = 0x2C
+
+      # Each column in the controller's RAM is 12 pixels wide.
+      # The hardware suppports column addresses 20..39 and
+      # for a 122 pixel wide display, the first used column is 25.
+      RAM_COLUMN_START = 25
+
+      # Treat memory rows as columns, and columns as rows. Bytes will fall properly.
+      COLUMNS = 250
+      ROWS    = 122
+
+      after_initialize do
+        reset.high if reset
+        dc.high
+        sleep 0.1
+
+        command [HPM]
+        command [NVMLOADEN];    data [0x02]
+        command [NVMLOADCTRL];  data [0x68]
+        command [BSTEN];        data [0x01]
+        command [GCTRL];        data [0x80]
+        command [SCTRL1];       data [0x28, 0x28, 0x28, 0x28, 0x14, 0x00]
+        command [SCTRL2];       data [0x00, 0x00, 0x00, 0x00]
+        command [VCOMCTRL];     data [0x14]
+        command [GATEUPDEQ];    data [0xE5, 0x77, 0xF1, 0xFF, 0xFF, 0x4F, 0xF1, 0xFF, 0xFF, 0x4F]
+        command [SLPOUT]
+        sleep 0.1
+
+        command [OSC_EN];   data [0xA6, 0xE9]
+        command [DUTYSET];  data [0x64]
+        command [MADCTL];   data [0x20] # HW column auto-increments after last line. Important!
+        command [DTFORM];   data [0x11]
+        command [SOCSET];   data [0x23]
+        command [PNLSET];   data [0x09]
+        command [DISPON]
+        command [SOCSET];   data [0xE3]
+        sleep 0.1
+        command [SOCSET];   data [0x23]
+        sleep 0.1
+
+        self.frame_rate = 8
+      end
+
+      def invert_on
+        command [INVON]
+      end
+
+      def invert_off
+        command [INVOFF]
+      end
+
+      VALID_FRAME_RATES = {
+        # High power mode
+        32    => [0x1, 0x0],
+        16    => [0x0, 0x0],
+        # Low power mode
+        8     => [0x0, 0x5],
+        4     => [0x0, 0x4],
+        2     => [0x0, 0x3],
+        1     => [0x0, 0x2],
+        0.5   => [0x0, 0x1],
+        0.25  => [0x0, 0x0]
+      }
+      def frame_rate=(fps)
+        raise ArgumentError, "Invalid frame rate: #{fps} given" unless VALID_FRAME_RATES.keys.include? fps
+        power_mode = (fps > 8) ? HPM : LPM
+        command [power_mode]
+        command [FRCTRL]
+        data VALID_FRAME_RATES[fps]
+      end
+
+      #
+      # This controller maps memory to pixels in a very unusual way, different to Canvas.
+      # Each "chunk" it accepts is 3 bytes (A through C below), representing:
+      # 2 pixels wide (2 columns in Canvas FB, or 1 "line" on the controller), by
+      # 12 pixels tall (1.5 pages in Canvas FB or 1 "column" on the controller):
+      #
+      # A7 A6 -
+      # A5 A4   |
+      # A3 A2   |  In framebuffer space this maps to:
+      # A1 A0   |- 2 complete bytes, sequential colummns, on same Canvas page,
+      # B7 B6   |  but they have to be interleaved in controller RAM
+      # B5 B4   |
+      # B3 B2   |
+      # B1 B0 -
+      # C7 C6 -
+      # C5 C4   |
+      # C3 C2   |- Same as above, but 2 low nibbles from 2 sequential bytes
+      # C1 C0 -
+      #
+      # For odd numbered "chunks", this is flipped. The corresponding high nibbles are first,
+      # then 2 whole bytes. Note that bit order is reversed compared to Canvas...
+      #
+      # Also note we are mapping Canvas framebuffer pages to what the controller calls "columns",
+      # and mapping framebuffer columns to what the controller calls "rows", essentially rotating it
+      # by 90 degrees. This makes it easier to transform a Canvas framebuffer into device RAM.
+      #
+      # Finally, use these 2 packing methods to take either the lower or upper nibbles
+      # from a pair of bytes, inteleave and reverse them to fit the format above.
+      #
+      def pack_lower4(left, right)
+        result = 0
+        (0..3).each do |index|
+          result |= ((left >> index) & 0b1)  << (7 - (index*2))
+          result |= ((right >> index) & 0b1) << (7 - (index*2 + 1))
+        end
+        result
+      end
+
+      def pack_upper4(left, right)
+        result = 0
+        (4..7).each do |index|
+          result |= ((left >> index) & 0b1)  << (7 - ((index-4)*2))
+          result |= ((right >> index) & 0b1) << (7 - ((index-4)*2 + 1))
+        end
+        result
+      end
+
+      def draw_partial(buffer, x_start, x_finish, p_start, p_finish, color=1)
+        # Controller does 2 pixels for each memory line. Ensure start on even.
+        x_start = (x_start / 2.0).floor * 2
+
+        # Because of weird RAM layout, always start partials on a framebuffer page divisible by 3.
+        # This corresponds to row divisible by 24, so a RAM column (12 px tall) divisible by 2.
+        # Always write to RAM in pairs of pages. Avoids keeping track of separated nibbles from buffer.
+        # Don't care to optimize this further.
+        page = (p_start / 3.0).floor * 3
+
+        # Each RAM column address is really 2 canvas columns.
+        ram_x_start = x_start / 2
+        ram_x_finish = (x_finish / 2.0).floor
+
+        while (page <= p_finish) do
+          upper_page = []
+          lower_page = []
+
+          x = x_start
+          while (x <= x_finish) do
+            # Take 6 bytes from the Canvas buffer, 2 columns across, 3 pages (24 rows) down.
+            a1_index = (page * columns)     + x
+            a2_index = ((page+1) * columns) + x
+            a3_index = ((page+2) * columns) + x
+            b1_index = (page * columns)     + x+1
+            b2_index = ((page+1) * columns) + x+1
+            b3_index = ((page+2) * columns) + x+1
+            a1 = buffer[a1_index] || 0
+            a2 = buffer[a2_index] || 0
+            a3 = buffer[a3_index] || 0
+            b1 = buffer[b1_index] || 0
+            b2 = buffer[b2_index] || 0
+            b3 = buffer[b3_index] || 0
+            # Transform them to match the RAM format, and add to their respective temp pages.
+            upper_page += [pack_lower4(a1, b1), pack_upper4(a1, b1), pack_lower4(a2, b2)]
+            lower_page += [pack_upper4(a2, b2), pack_lower4(a3, b3), pack_upper4(a3, b3)]
+            x += 2
+          end
+
+          # Transform from FB page index (8 px per page) to RAM column index (12 px per column).
+          ram_page = ((page * 8) / 12) + RAM_COLUMN_START
+
+          # Write two temp pages into 2 controller RAM columns.
+          command [CASET]; data [ram_page, ram_page+1]
+          command [RASET]; data [ram_x_start, ram_x_finish]
+          command [RAMWR]
+          upper_page.each_slice(transfer_limit) { |slice| data(slice) }
+          lower_page.each_slice(transfer_limit) { |slice| data(slice) }
+
+          # Advance 3 framebuffer pages since taking 24 rows each loop.
+          page += 3
+        end
+      end
+    end
+  end
+end

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,8 +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"
-    autoload :SH1106,   "#{__dir__}/display/sh1106"
+    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/{mutex_stub.rb → helpers/mutex_stub.rb}

@@ -3,5 +3,11 @@ module Denko
     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

@@ -13,6 +13,7 @@ module Denko
       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

data/lib/denko/i2c/bus_common.rb

@@ -12,11 +12,16 @@ module Denko
       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
+        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
@@ -25,8 +30,8 @@ module Denko
 
           # Array data from PiBoard.
           if data.class == Array
-            address = data.shift
-            bytes = data
+            address = data[0]
+            bytes = data[1..-1]
 
           # String data from microcontroller.
           elsif (data.class == String) && (data.match /\A\d+-/)

data/lib/denko/i2c/peripheral.rb

@@ -40,7 +40,11 @@ module Denko
       end
 
       def i2c_read(num_bytes, register: nil)
-        bus._read(i2c_address, register, num_bytes, i2c_frequency, i2c_repeated_start)
+        bus.read_nb(i2c_address, register, num_bytes, i2c_frequency, i2c_repeated_start)
+      end
+
+      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,8 +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 :BusCommon,  "#{__dir__}/i2c/bus_common"
-    autoload :Bus,        "#{__dir__}/i2c/bus"
-    autoload :BitBang,    "#{__dir__}/i2c/bit_bang"
-    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