denko 0.13.6 → 0.15.0

data/lib/denko/display/hd44780.rb

@@ -7,7 +7,8 @@ module Denko
   module Display
     class HD44780
       include Behaviors::MultiPin
-      
+      include Behaviors::Lifecycle
+
       # Commands
       LCD_CLEARDISPLAY   = 0x01
       LCD_RETURNHOME     = 0x02
@@ -17,13 +18,13 @@ module Denko
       LCD_FUNCTIONSET    = 0x20
       LCD_SETCGRAMADDR   = 0x40
       LCD_SETDDRAMADDR   = 0x80
-      
+
       # Flags for display entry mode
       LCD_ENTRYRIGHT          = 0x00
       LCD_ENTRYLEFT           = 0x02
       LCD_ENTRYSHIFTINCREMENT = 0x01
       LCD_ENTRYSHIFTDECREMENT = 0x00
-      
+
       # Flags for display on/off control
       LCD_DISPLAYON  = 0x04
       LCD_DISPLAYOFF = 0x00
@@ -31,13 +32,13 @@ module Denko
       LCD_CURSOROFF  = 0x00
       LCD_BLINKON    = 0x01
       LCD_BLINKOFF   = 0x00
-      
+
       # Flags for display/cursor shift
       LCD_DISPLAYMOVE = 0x08
       LCD_CURSORMOVE  = 0x00
       LCD_MOVERIGHT   = 0x04
       LCD_MOVELEFT    = 0x00
-      
+
       # Flags for function set
       LCD_8BITMODE = 0x10
       LCD_4BITMODE = 0x00
@@ -46,88 +47,110 @@ module Denko
       LCD_5x10DOTS = 0x04
       LCD_5x8DOTS  = 0x00
 
+      def data_lines
+        @data_lines ||= 4
+      end
+
+      # Default to 16x2 display if columns and rows given.
+      def columns
+        @columns ||= params[:columns] || 16
+      end
+
+      def rows
+        @rows ||= params[:rows] || 2
+      end
+
+      # Fuction set byte to set up the LCD. These OR'ed defaults == 0x00.
+      def function
+        @function ||= LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS
+      end
+
+      # Offset memory address when moving cursor.
+      # Row 2 always starts at memory address 0x40.
+      # For 4 line LCDs:
+      #   Row 3 is immediately after row 1, +16 or 20 bytes, depending on columns.
+      #   Row 4 is immediately after row 2, +16 or 20 bytes, depending on columns.
+      def row_offsets
+        @row_offsets ||= [0x00, 0x40, 0x00+columns, 0x40+columns]
+      end
+
+      # Start with cursor off and no cursor blink.
+      def control
+        @control ||= LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF
+      end
+
+      def entry_mode
+        @entry_mode ||= LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT
+      end
+
+      attr_writer :columns, :rows, :function, :data_lines, :row_offsets, :control, :entry_mode
+
       def initialize_pins(options={})
         # All the required pins.
         [:rs, :enable, :d4, :d5, :d6, :d7].each do |symbol|
           proxy_pin(symbol, DigitalIO::Output)
         end
-        
+
         # If any of d0-d3 was given, make them all non-optional.
         lower_bits_optional = (self.pins.keys & [:d0, :d1, :d2, :d3]).empty?
         [:d0, :d1, :d2, :d3].each do |symbol|
           proxy_pin(symbol, DigitalIO::Output, optional: lower_bits_optional)
         end
-        
-        # RW pin is mostly hard-wired to ground, but can given.
-        proxy_pin(:rw, DigitalIO::Output, optional: true)
+
+        # RW pin can be hardwired to GND, or given. Will be always pulled low.
+        proxy_pin :rw, DigitalIO::Output, optional: true
+
+        # Backlight can be hardwired, given here, or modeled as a separate component.
+        # If HD44780 is on a digital register, and PWM is desired, use a separate component.
+        proxy_pin :backlight, LED::Base, optional: true
       end
 
-      def after_initialize(options={})
-        super(options)
-        
-        # Default to 16x2 display if no options given.
-        @columns = options[:columns] || 16
-        @rows    = options[:rows]    || 2
-        
-        # Create a fuction set byte to set up the LCD. These defaults equal 0x00.
-        @function = LCD_4BITMODE | LCD_1LINE | LCD_5x8DOTS
-
-        # Set 8-bit mode in the mask if d0-d3 are present.
+      after_initialize do
+        # Switch to 8-bit mode if d0-d3 are present.
         if (d0 && d1 && d2 && d3)
-          @bits          = 8
-          @function |= LCD_8BITMODE
-        else
-          @bits = 4
+          self.data_lines = 8
+          self.function |= LCD_8BITMODE
         end
 
         # Set 2 line (row) mode if needed.
-        @function |= LCD_2LINE if (@rows > 1)
+        self.function |= LCD_2LINE if (rows > 1)
 
         # Some 1 line displays can use a 5x10 font.
-        @function |= LCD_5x10DOTS if options[:tall_font] && (@rows == 1)
-        
-        # Offset memory address when moving cursor.
-        # Row 2 always starts at memory address 0x40.
-        # For 4 line LCDs:
-        #   Row 3 is immediately after row 1, +16 or 20 bytes, depending on columns.
-        #   Row 4 is immediately after row 2, +16 or 20 bytes, depending on columns.
-        @row_offsets = [0x00, 0x40, 0x00+@columns, 0x40+@columns]
-        
+        self.function |= LCD_5x10DOTS if params[:tall_font] && (rows == 1)
+
         # Wait 50ms for power to be > 2.7V, then pull everything low.
         micro_delay(50000)
         enable.low; rs.low; rw.low if rw
 
         # Start in 4-bit mode.
-        if @bits == 4
+        if data_lines == 4
           # Keep setting 8-bit mode until ready.
           command(0x03); micro_delay(4500)
           command(0x03); micro_delay(4500)
           command(0x03); micro_delay(150)
-          
+
           # Set 4-bit mode.
           command(0x02)
-          
+
         # Or start in 8 bit mode.
         else
-          command(LCD_FUNCTIONSET | @function)
+          command(LCD_FUNCTIONSET | function)
           micro_delay(4500)
-          command(LCD_FUNCTIONSET | @function)
+          command(LCD_FUNCTIONSET | function)
           micro_delay(150)
-          command(LCD_FUNCTIONSET | @function)
+          command(LCD_FUNCTIONSET | function)
         end
-        
+
         # Set functions (lines, font size, etc.).
-        command(LCD_FUNCTIONSET | @function)
+        command(LCD_FUNCTIONSET | function)
 
-        # Start with cursor off and no cursor blink.
-        @control = LCD_DISPLAYON | LCD_CURSOROFF | LCD_BLINKOFF
         display_on
         clear
-        
-        # Set entry mode defaults.
-        @mode = LCD_ENTRYLEFT | LCD_ENTRYSHIFTDECREMENT
-        command(LCD_ENTRYMODESET | @mode)
-        
+        backlight.on if backlight
+
+        # Write entry mode.
+        command(LCD_ENTRYMODESET | entry_mode)
+
         # Need this small delay to avoid garbage data on startup.
         sleep 0.05
       end
@@ -142,17 +165,17 @@ module Denko
         micro_delay(2000)
       end
 
-      def set_cursor(col, row)
+      def text_cursor(col, row)
         # Limit to the highest row, 0 indexed.
-        row = (@rows - 1) if row > (@rows - 1)
-        command(LCD_SETDDRAMADDR | (col + @row_offsets[row]))
+        row = (rows - 1) if row > (rows - 1)
+        command(LCD_SETDDRAMADDR | (col + row_offsets[row]))
       end
-      alias :move_to :set_cursor
-      
-      def print(text)
-        text.each_byte { |b| write b }
+      alias :move_to :text_cursor
+
+      def text(str)
+        str.each_byte { |b| write b }
       end
-      
+
       #
       # Create a #key_on and #key_off method for each feature in this hash,
       # using the constant in the value to send a control signal.
@@ -160,58 +183,58 @@ module Denko
       # Eg. #display_on and #display_off.
       #
       CONTROL_TOGGLES = {
-        display: LCD_DISPLAYON,
-        cursor: LCD_CURSORON,
-        blink: LCD_BLINKON,
+        "display" => LCD_DISPLAYON,
+        "cursor"  =>  LCD_CURSORON,
+        "blink"   =>  LCD_BLINKON,
       }
       CONTROL_TOGGLES.each_key do |key|
-        define_method (key.to_s << "_off").to_sym do
-          command LCD_DISPLAYCONTROL | (@control &= ~CONTROL_TOGGLES[key])
+        define_method (key + "_off") do
+          command LCD_DISPLAYCONTROL | (self.control &= ~CONTROL_TOGGLES[key])
         end
-        define_method (key.to_s << "_on") do
-          command LCD_DISPLAYCONTROL | (@control |= CONTROL_TOGGLES[key])
+        define_method (key + "_on") do
+          command LCD_DISPLAYCONTROL | (self.control |= CONTROL_TOGGLES[key])
         end
       end
-      
+
       def left_to_right
-        @mode |= LCD_ENTRYLEFT
-        command(LCD_ENTRYMODESET | @mode)
+        self.entry_mode |= LCD_ENTRYLEFT
+        command(LCD_ENTRYMODESET | entry_mode)
       end
-      
+
       def right_to_left
-        @mode &= ~LCD_ENTRYLEFT
-        command(LCD_ENTRYMODESET | @mode)
+        self.entry_mode &= ~LCD_ENTRYLEFT
+        command(LCD_ENTRYMODESET | entry_mode)
       end
-      
+
       def scroll_left
         command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVELEFT)
       end
-      
+
       def scroll_right
         command(LCD_CURSORSHIFT | LCD_DISPLAYMOVE | LCD_MOVERIGHT)
       end
-      
+
       def autoscroll_on
-        @mode |= LCD_ENTRYSHIFTINCREMENT;
-        command(LCD_ENTRYMODESET | @mode);
+        self.entry_mode |= LCD_ENTRYSHIFTINCREMENT;
+        command(LCD_ENTRYMODESET | entry_mode);
       end
-      
+
       def autoscroll_off
-        @mode &= ~LCD_ENTRYSHIFTINCREMENT;
-        command(LCD_ENTRYMODESET | @mode);
+        self.entry_mode &= ~LCD_ENTRYSHIFTINCREMENT;
+        command(LCD_ENTRYMODESET | entry_mode);
       end
-      
+
       # Define custom characters as bitmaps.
       def create_char(location, bitmap)
         location &= 0x7
         command(LCD_SETCGRAMADDR | (location << 3))
         bitmap.each { |byte| write byte }
       end
-      
+
       def command(byte)
         send(byte, board.low)
       end
-      
+
       def write(byte)
         send(byte, board.high)
       end
@@ -219,38 +242,62 @@ module Denko
       def send(byte, rs_level)
         # RS pin goes low to send commands, high to send data.
         rs.write(rs_level) unless rs.state == rs_level
-        rw.low if rw
-        
+
         # Get the byte as a string of 0s and 1s, LSBFIRST.
         bits_from_byte = byte.to_s(2).rjust(8, "0").reverse
-        
+
         # Write bits depending on connection.
-        @bits == 8 ? write8(bits_from_byte) : write4(bits_from_byte)
+        data_lines == 8 ? write8(bits_from_byte) : write4(bits_from_byte)
       end
-      
+
       def write4(bits)
-        d4.write bits[4].to_i
-        d5.write bits[5].to_i
-        d6.write bits[6].to_i
-        d7.write bits[7].to_i
-        pulse_enable
-        d4.write bits[0].to_i
-        d5.write bits[1].to_i
-        d6.write bits[2].to_i
-        d7.write bits[3].to_i
-        pulse_enable
+        if board.is_a_register?
+          board.bit_set(d4.pin, bits[4].to_i)
+          board.bit_set(d5.pin, bits[5].to_i)
+          board.bit_set(d6.pin, bits[6].to_i)
+          d7.write bits[7].to_i
+          pulse_enable
+          board.bit_set(d4.pin, bits[0].to_i)
+          board.bit_set(d5.pin, bits[1].to_i)
+          board.bit_set(d6.pin, bits[2].to_i)
+          d7.write bits[3].to_i
+          pulse_enable
+        else
+          d4.write bits[4].to_i
+          d5.write bits[5].to_i
+          d6.write bits[6].to_i
+          d7.write bits[7].to_i
+          pulse_enable
+          d4.write bits[0].to_i
+          d5.write bits[1].to_i
+          d6.write bits[2].to_i
+          d7.write bits[3].to_i
+          pulse_enable
+        end
       end
 
       def write8(bits)
-        d0.write bits[0].to_i
-        d1.write bits[1].to_i
-        d2.write bits[2].to_i
-        d3.write bits[3].to_i
-        d4.write bits[4].to_i
-        d5.write bits[5].to_i
-        d6.write bits[6].to_i
-        d7.write bits[7].to_i
-        pulse_enable
+        if board.is_a_register?
+          board.bit_set(d0.pin, bits[0].to_i)
+          board.bit_set(d1.pin, bits[1].to_i)
+          board.bit_set(d2.pin, bits[2].to_i)
+          board.bit_set(d3.pin, bits[3].to_i)
+          board.bit_set(d4.pin, bits[4].to_i)
+          board.bit_set(d5.pin, bits[5].to_i)
+          board.bit_set(d6.pin, bits[6].to_i)
+          d7.write bits[7].to_i
+          pulse_enable
+        else
+          d0.write bits[0].to_i
+          d1.write bits[1].to_i
+          d2.write bits[2].to_i
+          d3.write bits[3].to_i
+          d4.write bits[4].to_i
+          d5.write bits[5].to_i
+          d6.write bits[6].to_i
+          d7.write bits[7].to_i
+          pulse_enable
+        end
       end
 
       def pulse_enable

data/lib/denko/display/il0373.rb

@@ -0,0 +1,186 @@
+module Denko
+  module Display
+    class IL0373
+      include SPIEPaperCommon
+      include Behaviors::Lifecycle
+
+      COLUMNS = 212
+      ROWS    = 104
+
+      # Subset of used commands from datasheet:
+      PANEL_SETTING           = 0x00
+      POWER_SETTING           = 0x01
+      POWER_OFF               = 0x02
+      POWER_OFF_SEQUENCE      = 0x03
+      POWER_ON                = 0x04
+      POWER_ON_MEASURE        = 0x05
+      BOOSTER_SOFT_START      = 0x06
+      DEEP_SLEEP              = 0x07
+      DATA_START_1            = 0x10
+      DATA_STOP               = 0x11
+      DISPLAY_REFRESH         = 0x12
+      DATA_START_2            = 0x13
+      VCOM_DATA_SETTING       = 0x50
+      RESOLUTION_SETTING      = 0x61
+      PARTIAL_WINDOW          = 0x90
+      PARTIAL_IN              = 0x91
+      PARTIAL_OUT             = 0x92
+
+      def set_power_setting
+        # Defaults from datasheet.
+        command [POWER_SETTING]
+        data    [0x03, 0x00, 0x26, 0x26, 0x03]
+      end
+
+      def set_panel_setting
+        # NOT DEFAULTS
+        # From datasheet:
+        #   Bits 7..6: Enable all source and gate channels
+        #       Bit 5: 0 = LUT from OTP
+        #       Bit 4: 0 = B/W/R mode, 1 = B/W mode
+        #       Bit 3: 0 = Gate scan decrements (1 increments)
+        #       Bit 2: 0 = Source scan decrements (1 increments)
+        #       Bit 1: 1 = Enable booster
+        #       Bit 0: 1 = Soft reset
+        value  = 0b0000_0011
+
+        # Handle colors
+        value |= (1 << 4) if colors == 2
+
+        # Handle screen size
+        source_gate_bits = 0b11
+        source_gate_bits = 0b10 if (rows <= 128)
+        source_gate_bits = 0b01 if (rows <= 96) && (columns <= 252)
+        source_gate_bits = 0b00 if (rows <= 96) && (columns <= 230)
+        value |= source_gate_bits
+
+        # Handle hardware reflection/rotation
+        value |= (1 << 2) if @reflect_y
+        value |= (1 << 3) if @reflect_x
+
+        command [PANEL_SETTING]
+        data    [value]
+      end
+
+      def reflect_x
+        @reflect_x = !@reflect_x
+      end
+
+      def reflect_y
+        @reflect_y = !@reflect_y
+      end
+
+      def rotate
+        @reflect_x = !@reflect_x
+        @reflect_y = !@reflect_y
+      end
+
+      def set_vcom_data_setting
+        # Default value from data sheet.
+        value = 0b0000_0111
+
+        # Datsheet may be wrong here. Bit 5 set seems to always invert DATA2, so Bit 4 does DATA1?
+        #   In B/W mode:   set bit 5 to avoid black channel inversion relative to Canvas.
+        #   In B/W/R mode: set bit 4 to avoid black channel inversion relative to Canvas.
+        if (colors == 2)
+          value |= (1 << 4) unless @invert_black
+        else
+          value |= (1 << 5) unless @invert_black
+        end
+
+        command [VCOM_DATA_SETTING]
+        data    [value]
+      end
+
+      def invert_black
+        @invert_black = !@invert_black
+      end
+
+      def set_resolution
+        command [RESOLUTION_SETTING]
+        data [
+          p_max+1 << 3,
+          (columns >> 8) & 0b1,
+          columns & 0xFF
+        ]
+      end
+
+      def booster_soft_start
+        # Defaults from datasheet.
+        command [BOOSTER_SOFT_START]
+        data    [0x17, 0x17, 0x17]
+      end
+
+      def power_on
+        command [POWER_ON]
+        busy_wait
+      end
+
+      def wake
+        hw_reset
+        set_power_setting
+        set_panel_setting
+        set_vcom_data_setting
+        set_resolution
+        booster_soft_start
+        power_on
+      end
+
+      def deep_sleep
+        # Default from datasheet.
+        command [DEEP_SLEEP]
+        data    [0xA5]
+      end
+
+      # Treat what the datasheet calls x as vertical (y, page), and vertical as horizontal (x).
+      def set_window(x_start=x_min, x_finish=x_max, p_start=p_min, p_finish=p_max)
+        command [PARTIAL_WINDOW]
+        data [
+          p_start  << 3,
+          p_finish << 3,
+          (x_start >> 8) & 0b1,
+          x_start & 0xFF,
+          (x_finish >> 8) & 0b1,
+          x_finish & 0xFF,
+          0b0
+        ]
+        command [PARTIAL_IN]
+      end
+
+      def draw(*args, **kwargs)
+        wake
+        super(*args, **kwargs)
+      end
+
+      def draw_partial(buffer, x_start, x_finish, p_start, p_finish, color=1)
+        set_window(x_start, x_finish, p_start, p_finish)
+
+        if (colors == 2)
+          # In B/W/Red mode, red goes in DATA2, black in DATA1
+          (color == 2) ? command[DATA_START_2] : command[DATA_START_1]
+        else
+          # In B/W mode, always write to DATA2
+          command [DATA_START_2]
+        end
+
+        # Can't control address increment to go horizontally, always vertical.
+        # So get partial from the full buffer and reorder the bytes.
+        transformed_buffer = []
+        (x_start..x_finish).each do |x|
+          (p_start..p_finish).to_a.reverse.each do |page|
+            index = (page * columns) + x
+            transformed_buffer << buffer[index]
+          end
+        end
+        transformed_buffer.each_slice(transfer_limit) { |slice| data(slice) }
+
+        command [DATA_STOP]
+      end
+
+      def refresh
+        command [DISPLAY_REFRESH]
+        busy_wait
+      end
+    end
+  end
+end