denko 0.13.0

data/lib/denko/display/canvas.rb

@@ -0,0 +1,282 @@
+module Denko
+  module Display
+    class Canvas
+      include Denko::Fonts
+
+      attr_reader :columns, :rows, :framebuffer
+    
+      def initialize(columns, rows)
+        raise ArgumentError, "bitmap height must be divisible by 8" unless (rows % 8 == 0)
+
+        @columns     = columns
+        @rows        = rows
+
+        # Use a byte array for the framebuffer. Each byte is 8 pixels arranged vertically.
+        # Each slice @columns long represents an area @columns wide * 8 pixels tall.
+        @bytes       = @columns * (@rows / 8)
+        @framebuffer = Array.new(@bytes) { 0x00 }
+      end
+
+      def fill
+        @framebuffer.fill(0xFF)
+      end
+
+      def clear
+        @framebuffer.fill(0x00)
+      end
+
+      def get_pixel(x, y)
+        byte = ((y / 8) * @columns) + x
+        bit  = y % 8
+        (@framebuffer[byte] >> bit) & 0b00000001
+      end
+
+      def set_pixel(x, y)
+        byte = ((y / 8) * @columns) + x
+        bit  = y % 8
+        @framebuffer[byte] |= (0b1 << bit)
+      end
+
+      def clear_pixel(x, y)
+        byte = ((y / 8) * @columns) + x
+        bit  = y % 8
+        @framebuffer[byte] &= ~(0b1 << bit)
+      end
+
+      def pixel(x, y, state=0)
+        (state == 0) ? clear_pixel(x, y) : set_pixel(x, y)
+      end
+
+      # Draw a line based on Bresenham's line algorithm.
+      def line(x1, y1, x2, y2, color=1)
+        # Deltas in each axis.
+        dy = y2 - y1
+        dx = x2 - x1
+
+        # Catch vertical lines to avoid division by 0.
+        if (dx == 0)
+          # Ensure y1 < y2.
+          y1, y2 = y2, y1 if (y2 < y1)
+          (y1..y2).each do |y|
+            pixel(x1, y, color)
+          end
+          return
+        end
+
+        gradient = dy.to_f / dx
+
+        # Gradient magnitude <= 45 degrees: find y for each x.
+        if (gradient >= -1) && (gradient <= 1)
+          # Ensure x1 < x2.
+          x1, y1, x2, y2 = x2, y2, x1, y1 if (x2 < x1)
+
+          # When x increments, add gradient to y.
+          y = y1
+          y_step = gradient
+          (x1..x2).each do |x|
+            pixel(x, y.round, color)
+            y = y + y_step
+          end
+
+        # Gradient magnitude > 45 degrees: find x for each y.
+        else
+          # Ensure y1 < y2.
+          x1, y1, x2, y2 = x2, y2, x1, y1 if (y2 < y1)
+
+          # When y increments, add inverse of gradient to x.
+          x = x1
+          x_step = 1 / gradient
+          (y1..y2).each do |y|
+            pixel(x.round, y, color)
+            x = x + x_step
+          end
+        end
+      end
+
+      # Rectangles and squares as a combination of lines.
+      def rectangle(x, y, width, height, color=1)
+        line(x,       y,        x+width, y,        color)
+        line(x+width, y,        x+width, y+height, color)
+        line(x+width, y+height, x,       y+height, color)
+        line(x,       y+height, x,       y,        color)
+      end
+
+      # Draw a vertical line for every x value to get a filled rectangle.
+      def filled_rectangle(x, y_start, width, height, color=1)
+        y_end = y_start + height
+        y_start, y_end = y_end, y_start if (y_end < y_start)
+        (y_start..y_end).each do |y|
+          line(x, y, x+width, y, color)
+        end
+      end
+
+      # Open ended path
+      def path(points=[], color=1)
+        return unless points
+        start = points[0]
+        (1..points.length-1).each do |i|
+          finish = points[i]
+          line(start[0], start[1], finish[0], finish[1])
+          start = finish
+        end
+      end
+
+      # Close paths by repeating the start value at the end.
+      def polygon(points=[], color=1)
+        points << points[0]
+        path(points)
+      end
+
+      # Filled polygon using horizontal ray casting + stroked polygon.
+      def filled_polygon(points=[], color=1)
+        # Get all the X and Y coordinates from the points as floats.
+        coords_x = points.map { |point| point.first.to_f }
+        coords_y = points.map { |point| point.last.to_f  }
+
+        # Get Y bounds of the polygon to limit rows.
+        y_min = coords_y.min.to_i
+        y_max = coords_y.max.to_i
+
+        # Cast horizontal ray on each row, storing nodes where it intersects polygon edges.
+        (y_min..y_max).each do |y|
+          nodes = []
+          i = 0
+          j = points.count - 1
+
+          while (i < points.count) do
+            if (coords_y[i] < y && coords_y[j] >= y || coords_y[j] < y && coords_y[i] >= y)
+              nodes << (coords_x[i] + (y - coords_y[i]) / (coords_y[j] - coords_y[i]) *(coords_x[j] - coords_x[i])).round
+            end
+            j  = i
+            i += 1
+          end
+          nodes = nodes.sort
+
+          # Take pairs of nodes and fill between them. This automatically ignores the spaces
+          # between even then odd nodes, which are outside the polygon.
+          nodes.each_slice(2) do |pair|
+            next if pair.length < 2
+            line(pair.first, y,  pair.last, y, color)
+          end
+        end
+
+        # Stroke the polygon anyway. Floating point math misses thin areas.
+        polygon(points, color)
+      end
+      
+      # Triangle with 3 points as 6 flat args.
+      def triangle(x1, y1, x2, y2, x3, y3, color=1)
+        polygon([[x1,y1], [x2,y2], [x3,y3]], color)
+      end
+
+      # Filled triangle with 3 points as 6 flat args.
+      def filled_triangle(x1, y1, x2, y2, x3, y3, color=1)
+        filled_polygon([[x1,y1], [x2,y2], [x3,y3]], color)
+      end
+
+      # Midpoint ellipse / circle based on Bresenham's circle algorithm.
+      def ellipse(x_center, y_center, a, b, color=1, filled=false)
+        # Start position
+        x = -a
+        y = 0
+
+        # Precompute x and y increments for each step.
+        x_increment = 2 * b * b
+        y_increment = 2 * a * a
+
+        # Start errors
+        dx = (1 + (2 * x)) * b * b
+        dy = x * x
+        e1 = dx + dy
+        e2 = dx
+
+        # Since starting at max negative X, continue until x is 0.
+        while (x <= 0)
+          if filled
+            fill_quadrants(x_center, y_center, x, y, color)
+          else
+            stroke_quadrants(x_center, y_center, x, y, color)
+          end
+
+          e2 = 2 * e1
+          if (e2 >= dx)
+            x  += 1
+            dx += x_increment
+            e1 += dx
+          end
+          if (e2 <= dy)
+            y  += 1
+            dy += y_increment
+            e1 += dy
+          end
+        end
+
+        # Continue if y hasn't reached the vertical size.
+        while (y < b)
+          y += 1
+          pixel(x_center, y_center + y, color)
+          pixel(x_center, y_center - y, color)
+        end
+      end
+
+      def stroke_quadrants(x_center, y_center, x, y, color)
+        # Quadrants in order as if y-axis is reversed and going counter-clockwise from +ve X.
+        pixel(x_center - x, y_center - y, color)
+        pixel(x_center + x, y_center - y, color)
+        pixel(x_center + x, y_center + y, color)
+        pixel(x_center - x, y_center + y, color)
+      end
+
+      def fill_quadrants(x_center, y_center, x, y, color)
+        line(x_center - x, y_center + y, x_center + x, y_center + y, color)
+        line(x_center - x, y_center - y, x_center + x, y_center - y, color)
+      end
+
+      def circle(x_center, y_center, radius, color=1, filled=false)
+        ellipse(x_center, y_center, radius, radius, color, filled)
+      end
+
+      def filled_circle(x_center, y_center, radius, color=1)
+        ellipse(x_center, y_center, radius, radius, color, true)
+      end
+
+      def text_cursor=(array=[])
+        @text_cursor = array
+      end
+
+      def text_cursor
+        @text_cursor ||= [0, 7]
+      end
+
+      def print(str)
+        str.to_s.split("").each do |char|
+          print_char(char)
+        end
+      end
+
+      def print_char(char)
+        # 0th character in font is SPACE. Offset and limit to printable chars.
+        index = char.ord - 32
+        index = 0 if (index < 0 || index > 94)
+        char_map = FONT_6x8[index]
+
+        raw_char(char_map)
+      end
+
+      def raw_char(byte_array)
+        # Get the starting byte index.
+        page = text_cursor[1] / 8
+        byte_index = (@columns * page) + text_cursor[0]
+
+        # Replace those bytes in the framebuffer with the character.
+        byte_array.each do |byte| 
+          @framebuffer[byte_index] = byte
+          byte_index += 1
+        end
+
+        # Increment the text cursor.
+        self.text_cursor[0] += byte_array.length
+      end
+    end
+  end
+end

data/lib/denko/display/hd44780.rb

@@ -0,0 +1,266 @@
+#
+# Ruby implementation of Hitach HD44780 LCD support.
+# Based on the Adafruit_LiquidCrystal library:
+# https://github.com/adafruit/Adafruit_LiquidCrystal
+#
+module Denko
+  module Display
+    class HD44780
+      include Behaviors::MultiPin
+      
+      # Commands
+      LCD_CLEARDISPLAY   = 0x01
+      LCD_RETURNHOME     = 0x02
+      LCD_ENTRYMODESET   = 0x04
+      LCD_DISPLAYCONTROL = 0x08
+      LCD_CURSORSHIFT    = 0x10
+      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
+      LCD_CURSORON   = 0x02
+      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
+      LCD_2LINE    = 0x08
+      LCD_1LINE    = 0x00
+      LCD_5x10DOTS = 0x04
+      LCD_5x8DOTS  = 0x00
+
+      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)
+      end
+
+      def after_initialize(options={})
+        super(options) if defined?(super)
+        
+        # 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.
+        if (d0 && d1 && d2 && d3)
+          @bits          = 8
+          @function |= LCD_8BITMODE
+        else
+          @bits = 4
+        end
+
+        # Set 2 line (row) mode if needed.
+        @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]
+        
+        # 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
+          # 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)
+          micro_delay(4500)
+          command(LCD_FUNCTIONSET | @function)
+          micro_delay(150)
+          command(LCD_FUNCTIONSET | @function)
+        end
+        
+        # Set functions (lines, font size, etc.).
+        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)
+        
+        # Need this small delay to avoid garbage data on startup.
+        sleep 0.05
+      end
+
+      def clear
+        command(LCD_CLEARDISPLAY)
+        micro_delay(2000)
+      end
+
+      def home
+        command(LCD_RETURNHOME)
+        micro_delay(2000)
+      end
+
+      def set_cursor(col, row)
+        # Limit to the highest row, 0 indexed.
+        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 }
+      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.
+      #
+      # Eg. #display_on and #display_off.
+      #
+      CONTROL_TOGGLES = {
+        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])
+        end
+        define_method (key.to_s << "_on") do
+          command LCD_DISPLAYCONTROL | (@control |= CONTROL_TOGGLES[key])
+        end
+      end
+      
+      def left_to_right
+        @mode |= LCD_ENTRYLEFT
+        command(LCD_ENTRYMODESET | @mode)
+      end
+      
+      def right_to_left
+        @mode &= ~LCD_ENTRYLEFT
+        command(LCD_ENTRYMODESET | @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);
+      end
+      
+      def autoscroll_off
+        @mode &= ~LCD_ENTRYSHIFTINCREMENT;
+        command(LCD_ENTRYMODESET | @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
+
+      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)
+      end
+      
+      def write4(bits)
+        d4.write bits[4]
+        d5.write bits[5]
+        d6.write bits[6]
+        d7.write bits[7]
+        pulse_enable
+        d4.write bits[0]
+        d5.write bits[1]
+        d6.write bits[2]
+        d7.write bits[3]
+        pulse_enable
+      end
+
+      def write8(bits)
+        d0.write bits[0]
+        d1.write bits[1]
+        d2.write bits[2]
+        d3.write bits[3]
+        d4.write bits[4]
+        d5.write bits[5]
+        d6.write bits[6]
+        d7.write bits[7]
+        pulse_enable
+      end
+
+      def pulse_enable
+        enable.low
+        micro_delay 1
+        enable.high
+        micro_delay 1
+        enable.low
+        micro_delay 100
+      end
+    end
+  end
+end