denko 0.13.6 → 0.14.0

data/lib/denko/digital_io/rotary_encoder.rb

@@ -3,103 +3,121 @@ module Denko
     class RotaryEncoder
       include Behaviors::MultiPin
       include Behaviors::Callbacks
+      include Behaviors::Lifecycle
+
+      before_initialize do
+        # Allow pins to be given as printed on common parts.
+        unless params[:pins][:a]
+          params[:pins][:a] = params[:pins][:clk] if params[:pins][:clk]
+          params[:pins][:a] = params[:pins][:clock] if params[:pins][:clock]
+        end
+        unless params[:pins][:b]
+          params[:pins][:b] = params[:pins][:dt] if params[:pins][:dt]
+          params[:pins][:b] = params[:pins][:data] if params[:pins][:data]
+        end
+
+        # But always refer to them as a and b internally.
+        [:clk, :clock, :dt, :data].each { |key| params[:pins].delete(key) }
+      end
+
+      def initialize_pins(params={})
+        proxy_pin :a, DigitalIO::Input
+        proxy_pin :b, DigitalIO::Input
+      end
+
+      after_initialize do
+        a.debounce_time = debounce_time
+        b.debounce_time = debounce_time
+        a.listen(divider)
+        b.listen(divider)
+
+        # Let initial state settle.
+        sleep 0.010
 
-      def initialize_pins(options={})
-        proxy_pin :clock, DigitalIO::Input
-        proxy_pin :data,  DigitalIO::Input
-      end
-
-      def after_initialize(options={})
-        super(options)
-        self.steps_per_revolution = options[:steps_per_revolution] || 30
-        @reverse = false
-
-        # Avoid repeated memory allocation.
-        self.state = { steps: 0, angle: 0 }
-        @reading   = { steps: 0, angle: 0, change: 0}
-        
-        # DigitalInputs listen with default divider automatically. Override here.
-        @divider = options[:divider] || 1
-        clock.listen(@divider)
-        data.listen(@divider)
-        
         observe_pins
         reset
       end
-      
-      attr_reader :reversed
+
+      # PiBoard will use GPIO alerts, default to 1 microsecond debounce time.
+      def debounce_time
+        @debounce_time ||= params[:debounce_time] || 1
+      end
+
+      # Board will default to 1ms digital listeners.
+      def divider
+        @divider ||= params[:divider] || 1
+      end
+
+      def reversed
+        @reversed ||= false || params[:reversed] || params[:reverse]
+      end
 
       def reverse
         @reversed = !@reversed
       end
 
-      def steps_per_revolution
-        (360 / @degrees_per_step).to_i
+      def counts_per_revolution
+        @counts_per_revolution ||= params[:counts_per_revolution] || params[:cpr] || 60
+      end
+
+      def degrees_per_count
+        @degrees_per_count ||= (360 / counts_per_revolution.to_f)
       end
-      
-      def steps_per_revolution=(step_count)
-        @degrees_per_step = 360.to_f / step_count
+
+      def state
+        state_mutex.synchronize { @state ||= { count: 0, angle: 0 } }
+      end
+
+      def reading
+        @reading ||= { count: 0, angle: 0, change: 0 }
       end
-      
+
       def angle
         state[:angle]
       end
 
-      def steps
-        state[:steps]
+      def count
+        state[:count]
       end
-      
+
       def reset
-        self.state = {steps: 0, angle: 0}
+        self.state = {count: 0, angle: 0}
       end
-      
+
       private
 
       def observe_pins
-        #
-        # This is a quirk of listeners reading in numerical order.
-        # When observing the pins, attach a callback to the higher numbered pin (trailing),
-        # then read state of the lower numbered (leading). If not, direction will be reversed.
-        #
-        if clock.pin > data.pin
-          trailing = clock
-          leading = data
-        else
-          trailing = data
-          leading = clock
+        a.add_callback do |a_state|
+          self.update((a_state == b.state) ? 1 : -1)
         end
-        
-        trailing.add_callback do |trailing_state|
-          change = (trailing_state == leading.state) ? 1 : -1
-          change = -change if trailing == clock
-          self.update(change)
+
+        b.add_callback do |b_state|
+          self.update((b_state == a.state) ? -1 : 1)
         end
       end
-      
+
       #
       # Take data (+/- 1 step change) and calculate new state.
-      # Return a hash with the new :steps and :angle. Pass through raw
+      # Return a hash with the new :count and :angle. Pass through raw
       # value in :change, so callbacks can use any of these.
       #
       def pre_callback_filter(step)
         step = -step if reversed
 
-        @reading[:change] = step
-        @state_mutex.synchronize do
-          @reading[:steps] = @state[:steps] + step
-        end      
-        @reading[:angle] = @reading[:steps] * @degrees_per_step % 360
-        
-        @reading
+        state_mutex.synchronize { reading[:count] = @state[:count] + step }
+        reading[:change] = step
+        reading[:angle]  = reading[:count] * degrees_per_count % 360
+
+        reading
       end
 
       #
       # After callbacks, set state to the hash from before, except change.
       #
       def update_state(reading)
-        @state_mutex.synchronize do
-          @state[:steps]  = reading[:steps]
-          @state[:angle]  = reading[:angle]
+        state_mutex.synchronize do
+          @state[:count] = reading[:count]
+          @state[:angle] = reading[:angle]
         end
       end
     end

data/lib/denko/digital_io.rb

@@ -5,5 +5,6 @@ module Denko
     autoload :Button,         "#{__dir__}/digital_io/button"
     autoload :Relay,          "#{__dir__}/digital_io/relay"
     autoload :RotaryEncoder,  "#{__dir__}/digital_io/rotary_encoder"
+    autoload :CBitBang,       "#{__dir__}/digital_io/c_bit_bang"
   end
 end

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,105 @@ module Denko
       LCD_5x10DOTS = 0x04
       LCD_5x8DOTS  = 0x00
 
+      def bits
+        @bits ||= 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, :bits, :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)
       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.bits = 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 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)
+          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)
-        
+
+        # Write entry mode.
+        command(LCD_ENTRYMODESET | entry_mode)
+
         # Need this small delay to avoid garbage data on startup.
         sleep 0.05
       end
@@ -144,15 +162,15 @@ module Denko
 
       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]))
+        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.
@@ -166,52 +184,52 @@ module Denko
       }
       CONTROL_TOGGLES.each_key do |key|
         define_method (key.to_s << "_off").to_sym do
-          command LCD_DISPLAYCONTROL | (@control &= ~CONTROL_TOGGLES[key])
+          command LCD_DISPLAYCONTROL | (self.control &= ~CONTROL_TOGGLES[key])
         end
         define_method (key.to_s << "_on") do
-          command LCD_DISPLAYCONTROL | (@control |= CONTROL_TOGGLES[key])
+          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
@@ -220,37 +238,62 @@ module Denko
         # 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)
+        bits == 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_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_has_write_bit?
+          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/sh1106.rb

@@ -0,0 +1,42 @@
+require_relative 'ssd1306'
+
+module Denko
+  module Display
+    class SH1106 < SSD1306
+      #
+      # Unlike the SSD1306, SH1106 only supports page addressing mode.
+      # Can't send all data as sequential pages and let page index auto-increment,
+      # like with horizontal addressing on the SSD1306.
+      #
+      ADDRESSING_MODE_DEFAULT = 0x02
+
+      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
+
+        # Offset x_min by 2, since SH1106 has RAM for 132 columns, but we only use 128, then convert to nibbles.
+        x = x_min + 2
+        x_lower = (x & 0b00001111)
+        x_upper = (x & 0b11110000) >> 4
+
+        (p_min..p_max).each do |page|
+          # Set the page and column to start writing at.
+          command [PAGE_START | page, COLUMN_START_LOWER | x_lower, COLUMN_START_UPPER | x_upper]
+
+          # Get needed bytes for this page only.
+          src_start = (@columns * page) + x_min
+          src_end   = (@columns * page) + x_max
+          buffer    = canvas.framebuffer[src_start..src_end]
+
+          # Send all bytes at once if within limit, or split into chunks.
+          if buffer.length < (bus.board.i2c_limit - 1)
+            data(buffer)
+          else  
+            buffer.each_slice(bus.board.i2c_limit - 1) { |slice| data(slice) }
+          end
+        end
+      end
+    end
+  end
+end