betabrite 0.0.2 → 1.0.0

data/lib/betabrite/autotest.rb

@@ -0,0 +1,43 @@
+require 'betabrite'
+
+module Autotest::BetaBrite
+  @@first_run = true
+
+  def self.hook(klass, *args, &block)
+    Autotest.add_hook :ran_command do |at|
+      if at.results.last =~ /^.* (\d+) failures, (\d+) errors$/
+        bb = klass.new(*args) do |sign|
+          sign.allocate do |memory|
+            memory.text('A', 4096)
+            memory.string('0', 128)
+            memory.string('1', 128)
+          end
+
+          failures  = BetaBrite::String.new("#{$1} failures").red
+          errors    = BetaBrite::String.new("#{$2} errors").red
+          failures.green if $1 == '0'
+          errors.green if $2 == '0'
+          block.call(failures, errors) if block
+
+          sign.stringfile('0') do
+            print failures
+          end
+          sign.stringfile('1') do
+            print errors
+          end
+
+          if @@first_run
+            sign.textfile do
+              print stringfile('0')
+              print " "
+              print stringfile('1')
+            end
+          end
+        end
+        bb.write_memory! if @@first_run
+        bb.write!
+        @@first_run = false if @@first_run
+      end
+    end
+  end
+end

data/lib/betabrite/base.rb

@@ -0,0 +1,86 @@
+module BetaBrite
+  VERSION   = '1.0.0'
+
+  class Base
+    include BetaBrite::Files
+
+    # = Synopsis
+    # This class assembles all packets (different files) and yields the data
+    # that needs to be written back to the caller of the BetaBrite#write method.
+    HEADER    = [ 0x00, 0x00, 0x00, 0x00, 0x00, 0x01 ]
+    STX       = 0x02.chr
+    ETX       = 0x03.chr
+    EOT       = 0x04.chr
+    ESC       = 0x1b.chr
+    DLE       = 0x10.chr
+    STRING    = 0x14.chr
+    CR        = 0x0d.chr
+    MEMORY_CODE = "E$"
+
+    # Beta Brite sign
+    SIGN_TYPE = 0x5a.chr
+
+    attr_accessor :sleep_time
+    attr_reader :string_files, :text_files, :dots_files, :memory
+
+    def initialize
+      # Default address is "00" which means broadcast to all signs
+      @sign_address = [ 0x30, 0x30 ]
+      @string_files = []
+      @text_files   = []
+      @dots_files   = []
+      @memory       = []
+
+      # This shouldn't change except for unit testing
+      @sleep_time = 0
+      yield self if block_given?
+    end
+
+    def textfile(label = 'A', &block)
+      @text_files << Text.new(label, &block)
+    end
+
+    def stringfile(label, message = nil, &block)
+      @string_files << Files::String.new(label, message, &block)
+    end
+
+    def dotsfile(label, rows = nil, columns = nil, picture = nil, &block)
+      @dots_files << Dots.new(label, rows, columns, picture,&block)
+    end
+
+    def allocate(&block)
+      @memory.push(*(BetaBrite::Memory::Factory.find(&block)))
+    end
+
+    def clear_memory!
+      @memory = []
+      self.write_memory!
+    end
+
+    # Get the message to be sent to the sign
+    def message
+      header +
+        @text_files.each { |tf| tf.to_s }.join('') +
+        @string_files.each { |tf| tf.to_s }.join('') +
+        @dots_files.each { |tf| tf.to_s }.join('') +
+        tail
+    end
+
+    def memory_message
+    "#{header}#{STX}#{MEMORY_CODE}#{@memory.map { |packet| packet.to_s }.join('')}#{tail}"
+    end
+
+    private
+
+    def header
+      header_str = HEADER.collect { |a| a.chr }.join
+      "#{header_str}#{SIGN_TYPE}#{@sign_address.collect { |a| a.chr }.join}"
+    end
+    alias :inspect :header
+    public :inspect
+
+    def tail
+      EOT
+    end
+  end
+end

data/lib/betabrite/files.rb

@@ -0,0 +1,4 @@
+require 'betabrite/files/file_dsl'
+require 'betabrite/files/string'
+require 'betabrite/files/text'
+require 'betabrite/files/dots'

data/lib/betabrite/files/dots.rb

@@ -0,0 +1,24 @@
+module BetaBrite
+  module Files
+    class Dots
+      COMMAND_CODE = 0x49.chr
+
+      attr_accessor :label, :rows, :columns, :picture
+
+      def initialize(label, rows, columns, picture, &block)
+        @label    = label
+        @rows     = rows
+        @columns  = columns
+        @picture  = picture
+        instance_eval(&block) if block
+      end
+
+      def to_s
+        string = "#{BetaBrite::Base::STX}#{COMMAND_CODE}#{@label.to_s}" +
+        "#{sprintf('%02x', @rows)}#{sprintf('%02x', @columns)}" +
+        "#{picture.join(BetaBrite::Base::CR)}#{BetaBrite::Base::CR}"
+      end
+      alias :to_str :to_s
+    end
+  end
+end

data/lib/betabrite/files/file_dsl.rb

@@ -0,0 +1,18 @@
+module BetaBrite
+  module FileDSL
+      def print(some_string)
+        @message = @message ? @message + some_string : some_string
+      end
+
+      def string(some_string)
+        BetaBrite::String.new(some_string)
+      end
+
+      ::BetaBrite::String.constants.each do |constant|
+        next unless constant =~ /^[A-Z_]*$/
+          define_method(:"#{constant.downcase}") do
+          ::BetaBrite::String.const_get(constant)
+          end
+      end
+  end
+end

data/lib/betabrite/files/string.rb

@@ -0,0 +1,22 @@
+module BetaBrite
+  module Files
+    class String
+      COMMAND_CODE = 'G'
+
+      attr_accessor :label, :message
+      include BetaBrite::FileDSL
+
+      def initialize(label = nil, message = nil, &block)
+        @label    = label
+        @message  = message
+        instance_eval(&block) if block
+      end
+
+      def to_s
+        "#{BetaBrite::Base::STX}#{COMMAND_CODE}#{@label.to_s}" +
+          "#{@message.to_s}#{BetaBrite::Base::ETX}"
+      end
+      alias :to_str :to_s
+    end
+  end
+end

data/lib/betabrite/files/text.rb

@@ -0,0 +1,122 @@
+module BetaBrite
+  module Files
+    class Text
+      WRITE   = 0x41.chr
+      READ    = 0x42.chr
+
+      class Position
+        MIDDLE  = 0x20.chr
+        TOP     = 0x22.chr
+        BOTTOM  = 0x26.chr
+        FILL    = 0x30.chr
+        LEFT    = 0x31.chr
+        RIGHT   = 0x32.chr
+      end
+
+      class Mode
+        # Standard Modes
+        ROTATE      = 0x61.chr # Message travels right to left
+        HOLD        = 0x62.chr # Message remains stationary
+        FLASH       = 0x63.chr # Message remains stationary and flashes
+        ROLL_UP     = 0x65.chr # Message is pushed up by new message
+        ROLL_DOWN   = 0x66.chr # Message is pushed down by new message
+        ROLL_LEFT   = 0x67.chr # Message is pushed left by a new message
+        ROLL_RIGHT  = 0x68.chr # Message is pushed right by a new message
+        WIPE_UP     = 0x69.chr # Message is wiped over bottom to top
+        WIPE_DOWN   = 0x6A.chr # Message is wiped over top to bottom
+        WIPE_LEFT   = 0x6B.chr # Message is wiped over right to left
+        WIPE_RIGHT  = 0x6C.chr # Message is wiped over left to right
+        SCROLL      = 0x6D.chr # New message pushes up if 2 line sign
+        AUTOMODE    = 0x6F.chr # Various modes are called automatically
+        ROLL_IN     = 0x70.chr # Message pushed toward center of display
+        ROLL_OUT    = 0x71.chr # Message pushed away from center of display
+        WIPE_IN     = 0x72.chr # Message wiped over in inward motion
+        WIPE_OUT    = 0x73.chr # Message wiped over in outward motion
+        COMPRESSED_ROTATE = 0x74.chr # Left to right, chars half normal width
+        EXPLODE     = 0x75.chr # Message flies apart (Alpha 3.0)
+        CLOCK       = 0x76.chr # Wipe in clockwise direction (Alpha 3.0)
+
+        # Special Modes
+        TWINKLE     = 0x6E.chr << 0x30.chr # Message will twinkle
+        SPARKLE     = 0x6E.chr << 0x31.chr # Message will sparkle
+        SNOW        = 0x6E.chr << 0x32.chr # Message will snow
+        INTERLOCK   = 0x6E.chr << 0x33.chr # Message will interlock
+        SWITCH      = 0x6E.chr << 0x34.chr # Message will switch
+        SLIDE       = 0x6E.chr << 0x35.chr # Message will slide
+        SPRAY       = 0x6E.chr << 0x36.chr # Message will spray across
+        STARBURST   = 0x6E.chr << 0x37.chr # Explodes message to screen
+        WELCOME     = 0x6E.chr << 0x38.chr # The world "Welcome" is written
+        SLOT_MACHINE= 0x6E.chr << 0x39.chr # Slot Machine shows up
+        NEWS_FLASH  = 0x6E.chr << 0x3A.chr # News flash animation
+        TRUMPET     = 0x6E.chr << 0x3B.chr # Trumpet animation
+        CYCLE_COLORS= 0x6E.chr << 0x43.chr # Color changes from one to another
+
+        # Special Graphics
+        THANK_YOU   = [0x6E, 0x53].pack('C*') # "Thank You" in script
+        FLAG        = [0x6E, 0x54].pack('C*') # American Flag
+        NO_SMOKING  = [0x6E, 0x55].pack('C*') # No smoking
+        DRINK_DRIVE = [0x6E, 0x56].pack('C*') # Don't drink and drive
+        ANIMAL_ANIM = [0x6E, 0x57].pack('C*') # Animal animation
+        FIREWORKS   = [0x6E, 0x58].pack('C*') # Fireworks animation
+        BALLOONS    = [0x6E, 0x59].pack('C*') # Balloon animation
+        CHERRY_BOMB = [0x6E, 0x5A].pack('C*') # A bomb animation or a smile
+        SMILE       = [0x6E, 0x5A].pack('C*') # A bomb animation or a smile
+      end
+
+      attr_accessor :label, :position, :mode, :message
+
+      include BetaBrite::FileDSL
+
+      def initialize(label = 'A', &block)
+        @position = Position::MIDDLE
+        @label = label
+        @message = nil
+        @mode  = Mode::ROTATE
+        instance_eval(&block) if block
+      end
+
+      def stringfile(label)
+      "#{BetaBrite::Base::DLE}#{label}"
+      end
+
+      def dotsfile(label)
+      "#{BetaBrite::Base::STRING}#{label}"
+      end
+
+      def to_s
+      "#{combine}#{checksum(combine)}"
+      end
+
+      def checksum(string)
+        total = 0
+        0.upto(string.length - 1) do |i|
+          total += string[i]
+        end
+
+        sprintf("%04x", total).upcase
+      end
+
+      Mode.constants.each do |constant|
+        next unless constant =~ /^[A-Z_]*$/
+          define_method(:"#{constant.downcase}") do
+            @mode = Mode.const_get(constant)
+            self
+          end
+      end
+
+      Position.constants.each do |constant|
+        next unless constant =~ /^[A-Z_]*$/
+          define_method(:"#{constant.downcase}") do
+            @position = Position.const_get(constant)
+            self
+          end
+      end
+
+      private
+      def combine
+        "#{BetaBrite::Base::STX}#{WRITE}#{@label}#{BetaBrite::Base::ESC}" +
+          "#{@position}#{@mode}#{@message}#{BetaBrite::Base::ETX}"
+      end
+    end
+  end
+end

data/lib/{memory → betabrite}/memory.rb

@@ -1,4 +1,4 @@
-class BetaBrite
+module BetaBrite
   class Memory
     COMMAND_CODE = "E$"
     TEXT         = 'A'
@@ -7,7 +7,7 @@ class BetaBrite
     LOCKED       = 'L'
     UNLOCKED     = 'U'
     def self.clear
-      BetaBrite::STX << COMMAND_CODE
+      BetaBrite::Base::STX << COMMAND_CODE
     end
 
     attr_accessor :label, :type, :locked, :size, :time
@@ -27,12 +27,34 @@ class BetaBrite
     end
 
     def format
-      #BetaBrite::STX << COMMAND_CODE << @label << @type << @locked <<
-      @label << @type << @locked << @size.upcase << @time
+      "#{@label}#{@type}#{@locked}#{@size.upcase}#{@time}"
     end
 
     alias :to_s :format
 
+    class Factory
+      attr_reader :memory_list
+      class << self
+        def find(&block)
+          @memory_list = []
+          instance_eval(&block)
+          @memory_list
+        end
+
+        def string(label, size)
+          @memory_list << String.new(label, size)
+        end
+
+        def text(label, size)
+          @memory_list << Text.new(label, size)
+        end
+
+        def dots(label, rows, columns)
+          @memory_list << Dots.new(label, rows, columns)
+        end
+      end
+    end
+
     class String < Memory
       def initialize(label, size)
         super(  :label  => label,
@@ -69,7 +91,7 @@ class BetaBrite
 
     class Clear < Memory
       def to_s
-        "#{BetaBrite::STX}#{COMMAND_CODE}"
+        "#{BetaBrite::Base::STX}#{COMMAND_CODE}"
       end
     end
   end

data/lib/betabrite/serial.rb

@@ -0,0 +1,28 @@
+module BetaBrite
+  class Serial < Base
+    def initialize(serialport)
+      @serialport = serialport
+      super()
+    end
+
+    def write_memory!
+      sp = SerialPort.new(@serialport, 9600, 8, 1, SerialPort::NONE)
+      characters = 0
+      memory_message.split(//).each do |chr|
+        sleep 1 if characters < 6
+        sp.write chr
+        characters += 1
+      end
+    end
+
+    def write!
+      sp = SerialPort.new(@serialport, 9600, 8, 1, SerialPort::NONE)
+      characters = 0
+      message.split(//).each do |chr|
+        sleep 1 if characters < 6
+        sp.write chr
+        characters += 1
+      end
+    end
+  end
+end

data/lib/{string.rb → betabrite/string.rb}

@@ -1,4 +1,4 @@
-class BetaBrite
+module BetaBrite
   # This class encapsulates a string and attributes about the string such as
   # color, character set, and also contains special characters.
   class String
@@ -54,6 +54,18 @@ class BetaBrite
     end
     attr_accessor :color, :charset, :string
 
+    class << self
+      # Break up a string into betabrite strings
+      def parse(string)
+        string.split(/#{0x1a.chr}/).select { |s|
+          s.length > 0
+        }.map { |s|
+          data = /(.)#{0x1c.chr}Z?([^Z]{6}|[^Z])(.*)$/.match(s)
+          new(data[3], :color => data[2], :charset => data[1])
+        }
+      end
+    end
+
     def initialize(string, opts = {})
       args = {  :color    => Color::GREEN,
                 :charset  => CharSet::SEVEN_HIGH
@@ -64,25 +76,39 @@ class BetaBrite
       yield self if block_given?
     end
 
-    def to_s
-      "#{0x1a.chr}#{@charset}#{0x1c.chr}#{@color}#{@string}"
+    def +(other)
+      self.to_s + other.to_s
     end
 
-    def method_missing(sym, *args)
-      if args.length > 0 && sym.to_s =~ /^set_(color|charset)$/
-        class_name = $1
+    def rgb(rgb_color)
+      self.color = "#{rgb_color}"
+      self
+    end
 
-        const_sym = class_name == 'color' ? :Color : :CharSet
+    def to_s
+      "#{0x1a.chr}#{@charset}#{0x1c.chr}" +
+        (@color.length > 1 ? "Z#{@color}" : "#{@color}") +
+        "#{@string}"
+    end
+    alias :to_str :to_s
+
+    Color.constants.each do |constant|
+      next unless constant =~ /^[A-Z_]*$/
+      define_method(:"#{constant.downcase}") do
+        @color = Color.const_get(constant)
+        self
+      end
+      define_method(:"#{constant.downcase}?") do
+        @color == Color.const_get(constant)
+      end
+    end
 
-        klass = self.class.const_get const_sym
-        if klass.const_defined? args.first.upcase.to_sym
-          return send("#{class_name}=".to_sym,
-                      klass.const_get(args.first.upcase.to_sym))
-        else
-          raise ArgumentError, "no constant #{args.first.upcase}", caller
-        end
+    CharSet.constants.each do |constant|
+      next unless constant =~ /^[A-Z_]*$/
+      define_method(:"#{constant.downcase}") do
+        @charset = CharSet.const_get(constant)
+        self
       end
-      super
     end
   end
 end