barkest_lcd 0.4.0

data/lib/models/hash_enum.rb

@@ -0,0 +1,91 @@
+module BarkestLcd
+  ##
+  # A simple enumeration class based on a hash of integers.
+  #
+  #   enum = HashEnum.new({ :alpha => 0x01, :bravo => 0x02, :charlie => 0x04 })
+  #   enum.alpha        # 1
+  #   enum.bravo        # 2
+  #   enum.CHARLIE      # 4
+  #   enum.alpha?(11)   # true
+  #   enum.BRAVO?(11)   # true
+  #   enum.charlie?(11) # false
+  #
+  class HashEnum
+
+    ##
+    # Turns a hash into an enumeration.
+    def initialize(hash = {})
+      @hash = hash.inject({}){ |memo,(k,v)| memo[k.to_sym] = v.to_i; memo }.freeze
+      # values ordered highest to lowest.
+      @flags = @hash.to_a.sort{|a,b| b[1] <=> a[1]}
+
+      freeze
+    end
+
+    # :nodoc:
+    def method_missing(meth, *args, &block)
+
+      if @hash.respond_to?(meth)
+        return @hash.send(meth, *args, &block)
+      end
+
+      [ meth.to_s.downcase.to_sym, meth.to_s.upcase.to_sym ].each do |test_meth|
+        if @hash.keys.include?(test_meth)
+          return @hash[test_meth]
+        else
+          meth_name = test_meth.to_s
+          is_flag = meth_name[-1] == '?'
+          if is_flag
+            test_meth = meth_name[0..-2].to_sym
+            if @hash.keys.include?(test_meth)
+              valid = @hash[test_meth]
+              test = args && args.count > 0 ? args.first : nil
+              raise ArgumentError, 'Missing value to test.' unless test
+              raise ArgumentError, 'Test value must be an integer.' unless test.is_a?(Fixnum)
+              return (test & valid) == valid
+            end
+          end
+        end
+      end
+
+      super meth, *args, &block
+    end
+
+    ##
+    # Determines what keys the value contains.
+    #
+    # If a remainder exists, then the remainder is added at the end of the returned array.
+    def flags(value)
+      ret = []
+      @flags.each do |(k,v)|
+        if (value & v) == v
+          value -= v
+          ret << k
+        end
+      end
+      ret << value if value != 0
+      ret
+    end
+
+    # :nodoc:
+    def inspect
+      @hash.inspect
+    end
+
+    # :nodoc:
+    def to_s
+      @hash.to_s
+    end
+
+    # :nodoc:
+    def ==(other)
+      @hash == other
+    end
+
+    # :nodoc:
+    def eql?(other)
+      @hash.eql?(other)
+    end
+
+  end
+end

data/lib/models/pico_lcd_graphic.rb

@@ -0,0 +1,184 @@
+
+require 'models/error_logger'
+
+module BarkestLcd
+  ##
+  # A class to interface with the picoLCD 256x64 (aka picoLCD Graphic) from [www.mini-box.com](http://www.mini-box.com).
+  #
+  #
+  class PicoLcdGraphic < ::HIDAPI::Device
+
+    include BarkestLcd::ErrorLogger
+
+    ##
+    # Any of the Pico LCD errors.
+    PicoLcdError = Class.new(StandardError)
+
+    ##
+    # The device has already been opened.
+    AlreadyOpen = Class.new(PicoLcdError)
+
+    ##
+    # The device is not currently open.
+    NotOpen = Class.new(PicoLcdError)
+
+    ##
+    # The device failed to open (no address returned).
+    OpenFailed = Class.new(PicoLcdError)
+
+    ##
+    # The operation has timed out.
+    Timeout = Class.new(PicoLcdError)
+
+    ##
+    # USB Vendor ID
+    VENDOR_ID     = 0x04d8
+
+    ##
+    # USB Device ID
+    DEVICE_ID     = 0xc002
+
+
+
+    ##
+    # Enumerates the picoLCD devices attached to the system.
+    def self.devices(refresh = false)
+      @devices = nil if refresh
+      @devices ||= HIDAPI.enumerate(VENDOR_ID, DEVICE_ID, as: 'BarkestLcd::PicoLcdGraphic')
+    end
+
+    ##
+    # Resets the device.
+    def reset
+      write [ OUT_REPORT.LCD_RESET, 0x01, 0x00 ]
+
+      (0...4).each do |csi|
+        cs = (csi << 2) & 0xFF
+        write [ OUT_REPORT.CMD, cs, 0x02, 0x00, 0x64, 0x3F, 0x00, 0x64, 0xC0 ]
+      end
+
+      reset_hook.each { |hook| hook.call(self) }
+
+      self
+    end
+
+
+    ##
+    # Processes any waiting input from the device and paints the screen if it is dirty.
+    def loop
+      data = read
+      if data && data.length > 0
+
+        type = data.getbyte(0)
+        data = data[1..-1]
+
+        input_hook(type).call(self, type, data)
+
+      end
+
+      loop_hook.each { |hook| hook.call(self) }
+
+      self
+    end
+
+
+
+    # :nodoc:
+    def self.method_missing(meth, *args, &block)
+      # pass through methods like 'first', 'count', 'each', etc to the 'devices' list.
+      list = devices
+      if list.respond_to?(meth)
+        list.send meth, *args, &block
+      else
+        super meth, *args, &block
+      end
+    end
+
+
+
+    protected
+
+
+    ##
+    # Hooks a block to run for a specific incoming type.
+    #
+    # Yields the device instance, type code, and the data to the block.
+    def input_hook(incoming_type, method_name = nil, &block)
+      @input_hook ||= {}
+
+      if block_given?
+        # set the hook.
+        @input_hook[incoming_type] = block
+      elsif method_name
+        @input_hook[incoming_type] = Proc.new { |dev, type, data| dev.send(method_name, dev, type, data) }
+      else
+        # get the hook
+        @input_hook[incoming_type] ||= Proc.new { |dev, type, data| HIDAPI.debug "no input hook for #{type} message type with #{data.length} bytes of data" }
+      end
+    end
+
+
+    ##
+    # Hooks a block to run during the loop method.
+    #
+    # Yields the device instance.
+    def loop_hook(method_name = nil, &block)
+      @loop_hook ||= []
+      if block_given?
+        @loop_hook << block
+      elsif method_name
+        @loop_hook << Proc.new { |dev| dev.send(method_name, dev) }
+      end
+      @loop_hook
+    end
+
+
+    ##
+    # Hooks a block to run during the reset method.
+    #
+    # Yields the device instance.
+    def reset_hook(method_name = nil, &block)
+      @reset_hook ||= []
+      if block_given?
+        @reset_hook << block
+      elsif method_name
+        @reset_hook << Proc.new { |dev| dev.send(method_name, dev) }
+      end
+      @reset_hook
+    end
+
+
+    ##
+    # Loops while the block returns true and the timeout hasn't expired.
+    def loop_while(options={}, &block)
+      timeout = options.delete(:timeout) || 2500
+      timeout = 10 if timeout < 10
+
+      result = block_given? ? block.call : true
+      while result
+        sleep 0.01
+        result = block_given? ? block.call : true
+        unless result
+          timeout -= 10
+          raise BarkestLcd::PicoLcdGraphic::Timeout if timeout < 0
+        end
+      end
+
+      true
+    end
+
+    # Turn off blocking for the PicoLcdGraphic.
+    # If the user decides, they can turn blocking back on.
+    init_hook do |dev|
+      dev.blocking = false
+    end
+
+
+
+  end
+end
+
+# Include the components of the model.
+Dir.glob(File.expand_path('../pico_lcd_graphic/*.rb', __FILE__)).each do |file|
+  require file
+end

data/lib/models/pico_lcd_graphic/display.rb

@@ -0,0 +1,97 @@
+require 'models/simple_graphic'
+
+BarkestLcd::PicoLcdGraphic.class_eval do
+  include BarkestLcd::SimpleGraphic
+
+  init_hook :init_display
+
+
+  ##
+  # Width of the screen in pixels.
+  SCREEN_W      = 256
+
+  ##
+  # Height of the screen in pixels.
+  SCREEN_H      = 64
+
+  ##
+  # Default contrast for the screen.
+  DEFAULT_CONTRAST  = 0xE5
+
+  ##
+  # Default brightness for the screen.
+  DEFAULT_BACKLIGHT = 0x7F
+
+
+  ##
+  # Sets the backlight level.
+  def backlight(level = 0xFF)
+    level &= 0xFF
+    write [ OUT_REPORT.LCD_BACKLIGHT, level ]
+    self
+  end
+
+
+  ##
+  # Sets the contrast level.
+  def contrast(level = 0xFF)
+    level &= 0xFF
+    write [ OUT_REPORT.LCD_CONTRAST, level ]
+    self
+  end
+
+
+  ##
+  # Sends the screen contents to the device.
+  def paint(force = false)
+    if dirty? || force
+      # 4 chips each holding 64x64 of data.
+      (0..3).each do |csi|
+        cs = (csi << 2)
+        # each memory line holds 64 bytes, or 8 rows of data.
+        (0..7).each do |line|
+          # use dirty rectangles to avoid sending unnecessary data to the device.
+          if force || dirty_rect?(csi * 64, line * 8, 64, 8)
+            # send the data in two packets for each memory line.
+            packet_1 = [ OUT_REPORT.CMD_DATA, cs, 0x02, 0x00, 0x00, 0xb8 | line, 0x00, 0x00, 0x40, 0x00, 0x00, 32 ]
+            packet_2 = [ OUT_REPORT.DATA, cs | 0x01, 0x00, 0x00, 32 ]
+
+            (0..63).each do |index|
+              # each byte holds the data for 8 rows.
+              byte = 0x00
+              (0..7).each do |bit|
+                x = (csi * 64) + index
+                y = ((line * 8) + bit) % height
+
+                byte |= (1 << bit) if get_bit(x, y)
+              end
+
+              # add the byte to the correct packet.
+              (index < 32 ? packet_1 : packet_2) << byte
+            end
+            # send the packets.
+            write packet_1
+            write packet_2
+          end
+        end
+      end
+      clear_dirty
+    end
+    self
+  end
+
+
+  private
+
+  def init_display(_)
+    init_graphic SCREEN_W, SCREEN_H
+    loop_hook { |_| paint }
+    reset_hook do |_|
+      clear.paint
+      contrast DEFAULT_CONTRAST
+      backlight DEFAULT_BACKLIGHT
+    end
+  end
+
+
+end

data/lib/models/pico_lcd_graphic/enums.rb

@@ -0,0 +1,107 @@
+require 'models/hash_enum'
+
+BarkestLcd::PicoLcdGraphic.class_eval do
+
+  ##
+  # Status codes that may be returned from the device.
+  STATUS = BarkestLcd::HashEnum.new(
+      OK:             0x00,
+      ERASE:          0x01,
+      WRITE:          0x02,
+      READ:           0x03,
+      ERROR:          0xFF,
+      KEY:            0x10,
+      IR:             0x11,
+      VER:            0x12,
+      DISCONNECTED:   0x13,
+  )
+
+  ##
+  # Reports received from the device.
+  IN_REPORT = BarkestLcd::HashEnum.new(
+      POWER_STATE:    0x01,
+      KEY_STATE:      0x11,
+      IR_DATA:        0x21,
+      EXT_EE_DATA:    0x31,
+      INT_EE_DATA:    0x32,
+  )
+
+  ##
+  # Reports sent to the device.
+  OUT_REPORT = BarkestLcd::HashEnum.new(
+      LED_STATE:      0x81,
+      LCD_BACKLIGHT:  0x91,
+      LCD_CONTRAST:   0x92,
+      CMD:            0x94,
+      DATA:           0x95,
+      CMD_DATA:       0x96,
+      LCD_RESET:      0x93,
+      RELAY_ONOFF:    0xB1,
+      TESTSPLASH:     0xC1,
+      EXT_EE_READ:    0xA1,
+      EXT_EE_WRITE:   0xA2,
+      INT_EE_READ:    0xA3,
+      INT_EE_WRITE:   0xA4,
+  )
+
+  ##
+  # Splash IDs.
+  ID_SPLASH = BarkestLcd::HashEnum.new(
+      TIMER:          0x72,
+      CYCLE_START:    0x72,
+      CYCLE_END:      0x73,
+  )
+
+
+  ##
+  # Types for flash operations.
+  FLASH_TYPE = BarkestLcd::HashEnum.new(
+      CODE_MEMORY:    0x00,
+      EPROM_EXTERNAL: 0x01,
+      EPROM_INTERNAL: 0x02,
+      CODE_SPLASH:    0x03,
+  )
+
+  ##
+  # HID reports for device.
+  HID_REPORT = BarkestLcd::HashEnum.new(
+      GET_VERSION_1:    0xF1,
+      GET_VERSION_2:    0xF7,
+      GET_MAX_STX_SIZE: 0xF6,
+      EXIT_FLASHER:     0xFF,
+      EXIT_KEYBOARD:    0xEF,
+      SET_SNOOZE_TIME:  0xF8,
+      ERROR:            0x10,
+  )
+
+  ##
+  # Flash reports for the device.
+  FLASH_REPORT = BarkestLcd::HashEnum.new(
+      ERASE_MEMORY:   0xF2,
+      READ_MEMORY:    0xF3,
+      WRITE_MEMORY:   0xF4,
+  )
+
+  ##
+  # Keyboard reports for the device.
+  KEYBD_REPORT = BarkestLcd::HashEnum.new(
+      ERASE_MEMORY:   0xB2,
+      READ_MEMORY:    0xB3,
+      WRITE_MEMORY:   0xB4,
+      MEMORY:         0x41,
+  )
+
+  ##
+  # Request results.
+  RESULT = BarkestLcd::HashEnum.new(
+      OK:                 0x00,
+      PARAM_MISSING:      0x01,
+      DATA_MISSING:       0x02,
+      BLOCK_READ_ONLY:    0x03,
+      BLOCK_NOT_ERASABLE: 0x04,
+      BLOCK_TOO_BIG:      0x05,
+      SECTION_OVERFLOW:   0x06,
+
+  )
+
+end