denko 0.13.0

data/lib/denko/display/ssd1306.rb

@@ -0,0 +1,179 @@
+require_relative 'canvas'
+
+module Denko
+  module Display
+    class SSD1306
+      include I2C::Peripheral
+
+      # Fundamental Commands
+        # Single byte (no need to OR with anything)
+        PIXELS_FROM_RAM = 0xA4
+        PIXELS_ALL_ON   = 0xA5
+        INVERT_OFF      = 0xA6
+        INVERT_ON       = 0xA7
+        DISPLAY_OFF     = 0xAE
+        DISPLAY_ON      = 0xAF
+
+        # Double byte (following byte sets value)
+        CONTRAST        = 0x81
+          # Values: 0x00 to 0xFF. Default is 0x7F
+
+      # Scrolling commands ignored.
+
+      # Address Setting Commands
+        # Single byte. OR with value. These are for page addressing mode only.
+        COLUMN_START_LOWER = 0x00 # lower 4 bytes of column
+        COLUMN_START_UPPER = 0x10 # upper 4 bytes of column
+        PAGE_START         = 0xB0 # page 0-7
+
+        # Double byte. Following byte sets value.
+        ADDRESSING_MODE    = 0x20
+          # Values: 0x00 = horizontal, 0x01 = vertical, 0x02 = page
+      
+        # Triple byte. Following 2 bytes sets value. For H/V addressing modes only.
+        COLUMN_ADDRESS_RANGE = 0x21
+        PAGE_ADDRESS_RANGE   = 0x22
+          # For both: first value = min column/row, second value = max column/row
+
+      # Hardware Configuration Commands
+        # Single byte. OR with value.
+        START_LINE      = 0x40  # Value: lowest 6 bits set RAM start line (default 0b000000)
+        SEGMENT_REMAP   = 0xA0  # Value: 0x00 = default, 0x01 = column draw order reversed (horizontal reflection)
+        COM_DIRECTION   = 0xC0  # Value: 0x00 = default, 0x08 = row draw order reversed (vertical reflection)
+
+        # Double-byte commands. Following byte sets value.
+        CHARGE_PUMP = 0x8D  # Value: 0x10 = disable/external, 0x14 = enable/internal
+        MULTIPLEX_RATIO = 0xA8  # Value: rows of display - 1
+        DISPLAY_OFFSET  = 0xD3  # Value: lowest 5 bits. Vertically shifts COM by that amount.
+        COM_PIN_CONFIG  = 0xDA
+          # 0x02 = sequential, left and right not swapped
+          # 0x12 = alternative, left and right not swapped (default)
+          # 0x22 = sequential, left and right sawpped
+          # 0x32 = alternative, left and right swapped
+
+      # Timing & Driving Commands
+        # Double-byte commands. Following byte sets value.
+        CLOCK               = 0xD5  # Lowest 4 bits = divider. Upper 4 bits = oscillator frequency.
+        PRECHARGE_PERIOD    = 0xD9  # Lowest 4 bits = phase 1. Upper 4 bits = phase 2. 0xF1 for internal charge pump. 0x22 for external.
+        VCOM_DESELECT_LEVEL = 0xDB  # 0x00 = 0.65 x Vcc, 0x20 = x 0.77 * Vcc (default), 0x30 = 0.83 x Vcc
+
+      # Valid widths and heights for displays
+      WIDTHS  = [64,96,128]
+      HEIGHTS = [16,32,48,64]
+
+      def before_initialize(options={})
+        @i2c_address   = 0x3C
+        @i2c_frequency = 400000
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        # Default to a 128x64 display.
+        @columns = options[:columns] || options[:width]  || 128
+        @rows    = options[:rows]    || options[:height] || 64
+
+        # Validate known sizes.
+        raise ArgumentError, "error in SSD1306 width: #{@columns}. Must be in: #{WIDTHS.inspect}" unless WIDTHS.include?(@columns)
+        raise ArgumentError, "error in SSD1306 height: #{@rows}. Must be in: #{HEIGHTS.inspect}" unless HEIGHTS.include?(@rows)
+
+        # Everything except 96x16 size uses clock 0x80.
+        clock = 0x80
+        clock = 0x60 if (@columns == 96 && @rows == 16)
+
+        # 128x32 and 96x16 sizes use com pin config 0x02
+        com_pin_config = 0x12
+        com_pin_config = 0x02 if (@columns == 96 && @rows == 16) || (@columns == 128 && @rows == 32)
+
+        # Reflecting horizontally and vertically to effectively rotate 180 degrees.
+        seg_remap     = options[:rotate] ? 0x01 : 0x00
+        com_direction = options[:rotate] ? 0x08 : 0x00
+
+        # Startup sequence
+        command [
+          MULTIPLEX_RATIO,        @rows - 1,
+          DISPLAY_OFFSET,         0x00,
+          START_LINE            | 0x00,
+          SEGMENT_REMAP         | seg_remap,
+          COM_DIRECTION         | com_direction,
+          COM_PIN_CONFIG,         com_pin_config,
+          PIXELS_FROM_RAM,
+          INVERT_OFF,
+          CLOCK,                  clock,
+          VCOM_DESELECT_LEVEL,    0x20,
+          PRECHARGE_PERIOD,       0xF1,           # Charge period for internal charge pump
+          CHARGE_PUMP,            0x14,           # Internal charge pump
+          ADDRESSING_MODE,        0x00,           # Horizontal addressing mode so pages auto increment
+          DISPLAY_ON
+        ]
+        
+        # Create a new blank canvas and draw it.
+        self.canvas = Canvas.new(@columns, @rows)
+        draw
+      end
+
+      attr_accessor :canvas
+
+      def off
+        command(DISPLAY_OFF)
+      end
+
+      def on
+        command(DISPLAY_ON)
+      end
+
+      def contrast=(value)
+        raise ArgumentError, "contrast must be in range 0..255" if (value < 0 || value > 255)
+        command [CONTRAST, value]
+      end
+
+      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
+        
+        # If drawing the whole frame (default), bypass temp buffer to save time.
+        if (x_min == 0) && (x_max == @columns-1) && (p_min == 0) && (p_max == @rows/8)
+          draw_partial(canvas.framebuffer, x_min, x_max, p_min, p_max)
+          
+        # Copy bytes for the given rectangle into a temp buffer. 
+        else
+          temp_buffer = []
+          (p_min..p_max).each do |page|
+            src_start = (@columns * page) + x_min
+            src_end   = (@columns * page) + x_max
+            temp_buffer += canvas.framebuffer[src_start..src_end]
+          end
+    
+          # And draw them.
+          draw_partial(temp_buffer, x_min, x_max, p_min, p_max)
+        end
+      end
+
+      def draw_partial(buffer, x_min, x_max, p_min, p_max)
+        # Limit auto-incrementing GRAM address to the rectangle being drawn.
+        command [ COLUMN_ADDRESS_RANGE, x_min, x_max, PAGE_ADDRESS_RANGE, p_min, p_max ]
+        
+        # Send all the bytes at once if within board I2C limit.
+        if buffer.length < (bus.board.i2c_limit - 1)
+          data(buffer)
+        
+        # Or split into chunks.
+        else  
+          buffer.each_slice(bus.board.i2c_limit - 1) { |slice| data(slice) }
+        end
+      end
+
+      # Commands are I2C messages prefixed with 0x00.
+      def command(bytes)
+        i2c_write([0x00] + bytes)
+      end
+
+      # Data are I2C messages prefixed with 0x40.
+      def data(bytes)
+        i2c_write([0x40] + bytes)
+      end
+    end
+  end
+end

data/lib/denko/display.rb

@@ -0,0 +1,7 @@
+module Denko
+  module Display
+    autoload :Canvas,   "#{__dir__}/display/canvas"
+    autoload :HD44780,  "#{__dir__}/display/hd44780"
+    autoload :SSD1306,  "#{__dir__}/display/ssd1306"
+  end
+end

data/lib/denko/eeprom/built_in.rb

@@ -0,0 +1,69 @@
+module Denko
+  module EEPROM
+    class BuiltIn
+      include Behaviors::Component
+      include Behaviors::Reader
+
+      public :state=
+
+      def pin
+        254
+      end
+
+      def after_initialize(options={})
+        super(options)
+        self.state = Array.new(board.eeprom_length, nil)
+        load
+      end
+
+      def load
+        state.each_slice(128).with_index do |slice, index|
+          read_using -> { board.eeprom_read(index * 128, slice.length) }
+        end
+      end
+
+      def save
+        @state_mutex.synchronize do
+          @state.each_slice(128).with_index do |slice, index|
+            board.eeprom_write(index * 128, slice)
+          end
+        end
+        load
+      end
+      
+      #
+      # Specific Array-like methods for convenience.
+      # 
+      def length; board.eeprom_length; end
+      alias :count :length
+      
+      def [](index)
+        @state_mutex.synchronize { @state.send :[], index }
+      end
+      
+      def []=(index, value)
+        @state_mutex.synchronize { @state.send :[]=, index, value }
+      end
+      
+      def each(&block)
+        @state_mutex.synchronize { @state.send :each, &block }
+      end
+      
+      def each_with_index(&block)
+        @state_mutex.synchronize { @state.send :each_with_index, &block }
+      end
+      
+      def pre_callback_filter(message)
+        address = message.split("-", 2)[0].to_i
+        bytes = message.split("-", 2)[1].split(",").map(&:to_i)
+        {address: address, data: bytes}
+      end
+
+      def update_state(hash)
+        @state_mutex.synchronize do
+          @state[hash[:address], hash[:data].length] = hash[:data]
+        end
+      end
+    end
+  end
+end

data/lib/denko/eeprom.rb

@@ -0,0 +1,5 @@
+module Denko
+  module EEPROM
+    autoload :BuiltIn, "#{__dir__}/eeprom/built_in"
+  end
+end

data/lib/denko/fonts.rb

@@ -0,0 +1,106 @@
+module Denko
+  module Fonts
+    #
+    # Adapted from:
+    # https://github.com/lexus2k/ssd1306/blob/master/src/ssd1306_fonts.c
+    #
+    FONT_6x8 = [
+      [0x00, 0x00, 0x00, 0x00, 0x00, 0x00], # sp
+      [0x00, 0x00, 0x00, 0x2f, 0x00, 0x00], # !
+      [0x00, 0x00, 0x07, 0x00, 0x07, 0x00], # "
+      [0x00, 0x14, 0x7f, 0x14, 0x7f, 0x14], # #
+      [0x00, 0x24, 0x2a, 0x7f, 0x2a, 0x12], # $
+      [0x00, 0x23, 0x13, 0x08, 0x64, 0x62], # %
+      [0x00, 0x36, 0x49, 0x55, 0x22, 0x50], # &
+      [0x00, 0x00, 0x05, 0x03, 0x00, 0x00], # '
+      [0x00, 0x00, 0x1c, 0x22, 0x41, 0x00], # (
+      [0x00, 0x00, 0x41, 0x22, 0x1c, 0x00], # )
+      [0x00, 0x14, 0x08, 0x3E, 0x08, 0x14], # *
+      [0x00, 0x08, 0x08, 0x3E, 0x08, 0x08], # +
+      [0x00, 0x00, 0x00, 0xA0, 0x60, 0x00], # ,
+      [0x00, 0x08, 0x08, 0x08, 0x08, 0x08], # -
+      [0x00, 0x00, 0x60, 0x60, 0x00, 0x00], # .
+      [0x00, 0x20, 0x10, 0x08, 0x04, 0x02], # /
+      [0x00, 0x3E, 0x51, 0x49, 0x45, 0x3E], # 0
+      [0x00, 0x00, 0x42, 0x7F, 0x40, 0x00], # 1
+      [0x00, 0x42, 0x61, 0x51, 0x49, 0x46], # 2
+      [0x00, 0x21, 0x41, 0x45, 0x4B, 0x31], # 3
+      [0x00, 0x18, 0x14, 0x12, 0x7F, 0x10], # 4
+      [0x00, 0x27, 0x45, 0x45, 0x45, 0x39], # 5
+      [0x00, 0x3C, 0x4A, 0x49, 0x49, 0x30], # 6
+      [0x00, 0x01, 0x71, 0x09, 0x05, 0x03], # 7
+      [0x00, 0x36, 0x49, 0x49, 0x49, 0x36], # 8
+      [0x00, 0x06, 0x49, 0x49, 0x29, 0x1E], # 9
+      [0x00, 0x00, 0x36, 0x36, 0x00, 0x00], # :
+      [0x00, 0x00, 0x56, 0x36, 0x00, 0x00], # ;
+      [0x00, 0x08, 0x14, 0x22, 0x41, 0x00], # <
+      [0x00, 0x14, 0x14, 0x14, 0x14, 0x14], # =
+      [0x00, 0x00, 0x41, 0x22, 0x14, 0x08], # >
+      [0x00, 0x02, 0x01, 0x51, 0x09, 0x06], # ?
+      [0x00, 0x32, 0x49, 0x59, 0x51, 0x3E], # @
+      [0x00, 0x7C, 0x12, 0x11, 0x12, 0x7C], # A
+      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x36], # B
+      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x22], # C
+      [0x00, 0x7F, 0x41, 0x41, 0x22, 0x1C], # D
+      [0x00, 0x7F, 0x49, 0x49, 0x49, 0x41], # E
+      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x01], # F
+      [0x00, 0x3E, 0x41, 0x49, 0x49, 0x7A], # G
+      [0x00, 0x7F, 0x08, 0x08, 0x08, 0x7F], # H
+      [0x00, 0x00, 0x41, 0x7F, 0x41, 0x00], # I
+      [0x00, 0x20, 0x40, 0x41, 0x3F, 0x01], # J
+      [0x00, 0x7F, 0x08, 0x14, 0x22, 0x41], # K
+      [0x00, 0x7F, 0x40, 0x40, 0x40, 0x40], # L
+      [0x00, 0x7F, 0x02, 0x0C, 0x02, 0x7F], # M
+      [0x00, 0x7F, 0x04, 0x08, 0x10, 0x7F], # N
+      [0x00, 0x3E, 0x41, 0x41, 0x41, 0x3E], # O
+      [0x00, 0x7F, 0x09, 0x09, 0x09, 0x06], # P
+      [0x00, 0x3E, 0x41, 0x51, 0x21, 0x5E], # Q
+      [0x00, 0x7F, 0x09, 0x19, 0x29, 0x46], # R
+      [0x00, 0x46, 0x49, 0x49, 0x49, 0x31], # S
+      [0x00, 0x01, 0x01, 0x7F, 0x01, 0x01], # T
+      [0x00, 0x3F, 0x40, 0x40, 0x40, 0x3F], # U
+      [0x00, 0x1F, 0x20, 0x40, 0x20, 0x1F], # V
+      [0x00, 0x3F, 0x40, 0x38, 0x40, 0x3F], # W
+      [0x00, 0x63, 0x14, 0x08, 0x14, 0x63], # X
+      [0x00, 0x07, 0x08, 0x70, 0x08, 0x07], # Y
+      [0x00, 0x61, 0x51, 0x49, 0x45, 0x43], # Z
+      [0x00, 0x00, 0x7F, 0x41, 0x41, 0x00], # [
+      [0x00, 0x02, 0x04, 0x08, 0x10, 0x20], # \
+      [0x00, 0x00, 0x41, 0x41, 0x7F, 0x00], # ]
+      [0x00, 0x04, 0x02, 0x01, 0x02, 0x04], # ^
+      [0x00, 0x40, 0x40, 0x40, 0x40, 0x40], # _
+      [0x00, 0x00, 0x01, 0x02, 0x04, 0x00], # '
+      [0x00, 0x20, 0x54, 0x54, 0x54, 0x78], # a
+      [0x00, 0x7F, 0x48, 0x44, 0x44, 0x38], # b
+      [0x00, 0x38, 0x44, 0x44, 0x44, 0x20], # c
+      [0x00, 0x38, 0x44, 0x44, 0x48, 0x7F], # d
+      [0x00, 0x38, 0x54, 0x54, 0x54, 0x18], # e
+      [0x00, 0x08, 0x7E, 0x09, 0x01, 0x02], # f
+      [0x00, 0x18, 0xA4, 0xA4, 0xA4, 0x7C], # g
+      [0x00, 0x7F, 0x08, 0x04, 0x04, 0x78], # h
+      [0x00, 0x00, 0x44, 0x7D, 0x40, 0x00], # i
+      [0x00, 0x40, 0x80, 0x84, 0x7D, 0x00], # j
+      [0x00, 0x7F, 0x10, 0x28, 0x44, 0x00], # k
+      [0x00, 0x00, 0x41, 0x7F, 0x40, 0x00], # l
+      [0x00, 0x7C, 0x04, 0x18, 0x04, 0x78], # m
+      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x78], # n
+      [0x00, 0x38, 0x44, 0x44, 0x44, 0x38], # o
+      [0x00, 0xFC, 0x24, 0x24, 0x24, 0x18], # p
+      [0x00, 0x18, 0x24, 0x24, 0x18, 0xFC], # q
+      [0x00, 0x7C, 0x08, 0x04, 0x04, 0x08], # r
+      [0x00, 0x48, 0x54, 0x54, 0x54, 0x20], # s
+      [0x00, 0x04, 0x3F, 0x44, 0x40, 0x20], # t
+      [0x00, 0x3C, 0x40, 0x40, 0x20, 0x7C], # u
+      [0x00, 0x1C, 0x20, 0x40, 0x20, 0x1C], # v
+      [0x00, 0x3C, 0x40, 0x30, 0x40, 0x3C], # w
+      [0x00, 0x44, 0x28, 0x10, 0x28, 0x44], # x
+      [0x00, 0x1C, 0xA0, 0xA0, 0xA0, 0x7C], # y
+      [0x00, 0x44, 0x64, 0x54, 0x4C, 0x44], # z
+      [0x00, 0x00, 0x08, 0x77, 0x00, 0x00], # {
+      [0x00, 0x00, 0x00, 0x7F, 0x00, 0x00], # |
+      [0x00, 0x00, 0x77, 0x08, 0x00, 0x00], # }
+      [0x00, 0x10, 0x08, 0x10, 0x08, 0x00], # ~
+      [0x14, 0x14, 0x14, 0x14, 0x14, 0x14], # horiz lines # DEL
+    ]
+  end
+end

data/lib/denko/i2c/bus.rb

@@ -0,0 +1,52 @@
+module Denko
+  module I2C
+    class Bus
+      include Behaviors::SinglePin
+      include Behaviors::BusControllerAddressed
+      include Behaviors::Reader
+
+      attr_reader :found_devices
+
+      def after_initialize(options={})
+        super(options)
+        @found_devices = []
+        bubble_callbacks
+      end
+
+      def search
+        addresses = read_using -> { board.i2c_search }
+        @found_devices = addresses.split(":").map(&:to_i) if addresses
+      end
+
+      def write(address, bytes, frequency=100000, repeated_start=false)
+        board.i2c_write(address, bytes, frequency, repeated_start)
+      end
+
+      def _read(address, register, num_bytes, frequency=100000, repeated_start=false)
+        board.i2c_read(address, register, num_bytes, frequency, repeated_start)
+      end
+      
+      def bubble_callbacks
+        add_callback(:bus_controller) do |str|
+          if str && str.match(/\A\d+-/)
+            address, data = str.split("-", 2)
+            address = address.to_i
+
+            data = data.split(",").map(&:to_i)
+            data = nil if data.empty?
+
+            update_component(address, data)
+          end
+        end
+      end
+
+      def update_component(address, data)
+        components.each do |component|
+          if component.address == address
+            component.update(data)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/denko/i2c/peripheral.rb

@@ -0,0 +1,38 @@
+module Denko
+  module I2C
+    module Peripheral
+      include Behaviors::BusPeripheralAddressed
+      include Behaviors::Reader
+
+      def before_initialize(options={})
+        # Allow peripherals to set @i2c_address.
+        @address            ||= @i2c_address
+
+        # I2C defaults if peripheral does not set.
+        @i2c_frequency      ||= 100000
+        @i2c_repeated_start ||= false
+
+        # Override defaults if given in options.
+        @i2c_frequency      = options[:i2c_frequency]      if options[:i2c_frequency]
+        @i2c_repeated_start = options[:i2c_repeated_start] if options[:i2c_frequency]
+
+        # Allow generic :address option to be given as :i2c_address before validation.
+        # Superclass method will hande override.
+        options[:address] ||= options[:i2c_address]
+
+        super(options)
+      end
+      
+      attr_accessor :i2c_repeated_start, :i2c_frequency
+      alias :i2c_address :address
+
+      def i2c_write(bytes=[])
+        bus.write(address, bytes, i2c_frequency, i2c_repeated_start)
+      end
+
+      def i2c_read(register, num_bytes)
+        bus._read(address, register, num_bytes, i2c_frequency, i2c_repeated_start)
+      end
+    end
+  end
+end

data/lib/denko/i2c.rb

@@ -0,0 +1,6 @@
+module Denko
+  module I2C
+    autoload :Bus,        "#{__dir__}/i2c/bus"
+    autoload :Peripheral, "#{__dir__}/i2c/peripheral"
+  end
+end

data/lib/denko/led/apa102.rb

@@ -0,0 +1,87 @@
+module Denko
+  module LED
+    class APA102
+      include SPI::Peripheral
+
+      attr_reader :length, :bpp, :brightness
+
+      def before_initialize(options={})
+        options[:pin] = 255
+        super(options)
+      end
+
+      def after_initialize(options={})
+        super(options)
+
+        raise ArgumentError, "no length given for APA102 array" unless options[:length]
+        @length = options[:length]
+
+        # Start frame is always 32 0-bits (4 bytes).
+        @start_frame = Array.new(4) { 0 }
+
+        # End frame must be at least @length/2 bits long, and 32 bits (4 bytes) minimum.
+        end_frame_bytes = (@length / 16.0).ceil
+        end_frame_bytes = 4 if end_frame_bytes < 4
+
+        # Use all 0's for end frame instead of 1's. Prevents extra pixel when using partial strip.
+        @end_frame = Array.new(end_frame_bytes) { 0 }
+
+        # This is BYTES per pixel, not bits per pixel.
+        # 0th byte is per-pixel brightness (PWM applied to all 3 colors).
+        @bpp = 4
+        @buffer = Array.new(length * bpp) { 0 }
+
+        # Default to max brightness.
+        self.brightness = 31
+        
+        off
+      end
+
+      # Global (per-strip) brightness control.
+      def brightness=(value)
+        value = 31 if value > 31
+        value = 0 if value < 0
+        @brightness = value
+
+        # @masked_brightness needs to set the 3 bits above the 5 used.
+        @masked_brightness = 0b11100000 | @brightness
+
+        # Set brightness for all pixels.
+        (0..@length-1).each do |index|
+          @buffer[index*bpp+0] = @masked_brightness
+        end
+      end
+
+      def []=(index, array)
+        # Per-pixel brightness control, as optional 3rd indexed element of array.
+        if array[3]
+          @buffer[index*bpp+0] = 0b11100000 | array[3]
+        end
+        
+        # APA102 uses BGR ordering.
+        @buffer[index*bpp+1] = array[2]
+        @buffer[index*bpp+2] = array[1]
+        @buffer[index*bpp+3] = array[0]
+      end
+
+      def all_on
+        self.brightness = 31
+        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,255,255,255] }.flatten
+        show
+      end
+
+      def off
+        clear
+        show
+      end
+
+      def clear
+        @buffer = @buffer.each_slice(bpp).map { [@masked_brightness,0,0,0] }.flatten
+      end
+
+      def show
+        spi_write(@start_frame + @buffer + @end_frame)
+      end
+    end
+  end
+end

data/lib/denko/led/base.rb

@@ -0,0 +1,12 @@
+module Denko
+  module LED
+    class Base < PulseIO::PWMOutput
+      def blink(interval=0.5)
+        threaded_loop do 
+          toggle
+          sleep interval
+        end
+      end
+    end
+  end
+end

data/lib/denko/led/rgb.rb

@@ -0,0 +1,38 @@
+module Denko
+  module LED
+    class RGB
+      include Behaviors::MultiPin
+
+      def initialize_pins(options={})
+        proxy_pin :red,   LED::Base
+        proxy_pin :green, LED::Base
+        proxy_pin :blue,  LED::Base
+      end
+
+      # Format: [R, G, B]
+      COLORS = {
+        red:     [255, 000, 000],
+        green:   [000, 255, 000],
+        blue:    [000, 000, 255],
+        cyan:    [000, 255, 255],
+        yellow:  [255, 255, 000],
+        magenta: [255, 000, 255],
+        white:   [255, 255, 255],
+        off:     [000, 000, 000]
+      }
+
+      def write(array)
+        red.write   array[0]
+        green.write array[1]
+        blue.write  array[2]
+      end
+
+      def color=(color)
+        return write(color) if color.class == Array
+
+        color = color.to_sym
+        write(COLORS[color]) if COLORS.include? color
+      end
+    end
+  end
+end