printer 0.1.0

data/Gemfile

@@ -0,0 +1,7 @@
+source :rubygems
+
+gem "serialport"
+
+group :test do
+  gem "mocha"
+end

data/lib/printer.rb

@@ -0,0 +1,332 @@
+require "serial_connection"
+
+class Printer
+  def initialize(connection)
+    @connection = connection
+    @print_mode = 0
+  end
+
+  def test_page
+    write_bytes(18, 84)
+  end
+
+  def begin(heat_time=150)
+    reset()
+
+    heat_interval = 50 # 2 is default from page 23 of datasheet. Controls speed of printing and darkness
+    print_density = 15 # Not sure what the defaut is. Testing shows the max helps darken text. From page 23.
+    print_break_time = 15 # Not sure what the defaut is. Testing shows the max helps darken text. From page 23.
+
+    write_bytes(27, 55)
+    write_bytes(7) # Default 64 dots = 8*('7'+1)
+    write_bytes(heat_time) # Default 80 or 800us
+    write_bytes(heat_interval) # Default 2 or 20us
+
+    # Modify the print density and timeout
+    write_bytes(18, 35)
+    print_setting = (print_density<<4) | print_break_time
+    write_bytes(print_setting) # Combination of print_density and print_break_time
+  end
+
+  # reset printer
+  def reset
+    write_bytes(27, 64)
+  end
+
+  # reset formatting
+  def set_default
+    online
+    normal
+    underline_off
+    justify(:left)
+    set_line_height(32)
+    set_barcode_height(50)
+  end
+
+  # Feeds by the specified number of lines
+  def feed(lines=1)
+    # The datasheet claims sending bytes 27, 100, <x> will work
+    # but it feeds much much more.
+    lines.times { write(10) }
+  end
+
+  # Feeds by the specified number of rows of pixels
+  def feed_rows(rows)
+    write_bytes(27, 74, rows)
+  end
+
+  def flush
+    write_bytes(12)
+  end
+
+  def test_page
+    write_bytes(18, 84)
+  end
+
+  def print(string)
+    string.bytes { |b| write(b) }
+  end
+
+  def println(string)
+    print(string + "\n")
+  end
+
+  def write(c)
+    return if (c == 0x13)
+    write_bytes(c)
+  end
+
+  def write_bytes(*bytes)
+    bytes.each { |b| @connection.putc(b) }
+  end
+
+  # Character commands
+
+  INVERSE_MASK = (1 << 1)
+  UPDOWN_MASK = (1 << 2)
+  BOLD_MASK = (1 << 3)
+  DOUBLE_HEIGHT_MASK = (1 << 4)
+  DOUBLE_WIDTH_MASK = (1 << 5)
+  STRIKE_MASK = (1 << 6)
+
+  def set_print_mode(mask)
+    @print_mode |= mask;
+    write_print_mode
+  end
+
+  def unset_print_mode(mask)
+    @print_mode &= ~mask;
+    write_print_mode
+  end
+
+  def write_print_mode
+    write_bytes(27, 33, @print_mode)
+  end
+
+  # This will reset bold, inverse, strikeout, upside down and font size
+  # It does not reset underline, justification or line height
+  def normal
+    @print_mode = 0
+    write_print_mode
+  end
+
+  def inverse_on
+    set_print_mode(INVERSE_MASK)
+  end
+
+  def inverse_off
+    unset_print_mode(INVERSE_MASK)
+  end
+
+  def upside_down_on
+    set_print_mode(UPDOWN_MASK);
+  end
+
+  def upside_down_off
+    unset_print_mode(UPDOWN_MASK);
+  end
+
+  def double_height_on
+    set_print_mode(DOUBLE_HEIGHT_MASK)
+  end
+
+  def double_height_off
+    unset_print_mode(DOUBLE_HEIGHT_MASK)
+  end
+
+  def double_width_on
+    set_print_mode(DOUBLE_WIDTH_MASK)
+  end
+
+  def double_width_off
+    unset_print_mode(DOUBLE_WIDTH_MASK)
+  end
+
+  def strike_on
+    set_print_mode(STRIKE_MASK)
+  end
+
+  def strike_off
+    unset_print_mode(STRIKE_MASK)
+  end
+
+  def bold_on
+    set_print_mode(BOLD_MASK)
+  end
+
+  def bold_off
+    unset_print_mode(BOLD_MASK)
+  end
+
+  def set_size(size)
+    byte = case size
+    when :small
+      0
+    when :medium
+      10
+    when :large
+      25
+    end
+
+    write_bytes(29, 33, byte, 10)
+  end
+
+  # Underlines of different weights can be produced:
+  # 0 - no underline
+  # 1 - normal underline
+  # 2 - thick underline
+  def underline_on(weight=1)
+    write_bytes(27, 45, weight)
+  end
+
+  def underline_off
+    underline_on(0)
+  end
+
+  def justify(position)
+    byte = case position
+    when :left
+      0
+    when :center
+      1
+    when :right
+      2
+    end
+
+    write_bytes(0x1B, 0x61, byte)
+  end
+
+  # Bitmaps
+
+  class Bitmap
+    attr_reader :width, :height
+
+    def initialize(width_or_source, height=nil, source=nil)
+      if height.nil? && source.nil?
+        set_source(width_or_source)
+        extract_width_and_height_from_data
+      else
+        set_source(source)
+        @width = width_or_source
+        @height = height
+      end
+    end
+
+    def each_block
+      row_start = 0
+      width_in_bytes = width / 8
+      while row_start < height do
+        chunk_height = ((height - row_start) > 255) ? 255 : (height - row_start)
+        bytes = (0...(width_in_bytes * chunk_height)).map { @data.getbyte }
+        yield width_in_bytes, chunk_height, bytes
+        row_start += 255
+      end
+    end
+
+    private
+
+    def set_source(source)
+      if source.respond_to?(:getbyte)
+        @data = source
+      else
+        @data = StringIO.new(source.map(&:chr).join)
+      end
+    end
+
+    def extract_width_and_height_from_data
+      tmp = @data.getbyte
+      @width = (@data.getbyte << 8) + tmp
+      tmp = @data.getbyte
+      @height = (@data.getbyte << 8) + tmp
+    end
+  end
+
+  def print_bitmap(*args)
+    bitmap = Bitmap.new(*args)
+    return if (bitmap.width > 384) # maximum width of the printer
+    bitmap.each_block do |w, h, bytes|
+      write_bytes(18, 42)
+      write_bytes(h, w)
+      write_bytes(*bytes)
+    end
+  end
+
+  # def print_bitmap(stream)
+  #   tmp = stream.getbyte
+  #   width = (stream.getbyte << 8) + tmp
+  #
+  #   tmp = stream.getbyte
+  #   height = (stream.getbyte << 8) + tmp
+  #
+  #   print_bitmap(width, height, stream)
+  # end
+
+  # Barcodes
+
+  def set_barcode_height(val)
+    # default is 50
+    write_bytes(29, 104, val)
+  end
+
+  UPC_A   = 0
+  UPC_E   = 1
+  EAN13   = 2
+  EAN8    = 3
+  CODE39  = 4
+  I25     = 5
+  CODEBAR = 6
+  CODE93  = 7
+  CODE128 = 8
+  CODE11  = 9
+  MSI     = 10
+
+  def print_barcode(text, type)
+    write_bytes(29, 107, type) # set the type first
+    text.bytes { |b| write(b) }
+    write(0) # Terminator
+  end
+
+  # Take the printer offline. Print commands sent after this will be
+  # ignored until `online` is called
+  def offline
+    write_bytes(27, 61, 0)
+  end
+
+  # Take the printer back online. Subsequent print commands will be
+  # obeyed.
+  def online
+    write_bytes(27, 61, 1)
+  end
+
+  # Put the printer into a low-energy state immediately
+  def sleep
+    sleep_after(0)
+  end
+
+  # Put the printer into a low-energy state after the given number
+  # of seconds
+  def sleep_after(seconds)
+    write_bytes(27, 56, seconds)
+  end
+
+  # Wake the printer from a low-energy state. This command will wait
+  # for 50ms (as directed by the datasheet) before allowing further
+  # commands to be send.
+  def wake
+    write_bytes(255)
+    # delay(50) # ?
+  end
+
+  # ==== not working? ====
+  def tab
+    write(9)
+  end
+
+  def set_char_spacing(spacing)
+    write_bytes(27, 32, 0, 10)
+  end
+
+  def set_line_height(val=32)
+    write_bytes(27, 51, val) # default is 32
+  end
+end

data/lib/serial_connection.rb

@@ -0,0 +1,18 @@
+require "serialport"
+
+class SerialConnection
+  def initialize(port=nil)
+    port_str = port || "/dev/tty.usbserial-FTF8DKJT"
+    baud_rate = 19200
+    data_bits = 8
+    stop_bits = 1
+    parity = SerialPort::NONE
+    @serial = SerialPort.new(port_str, baud_rate, data_bits, stop_bits, parity)
+    @serial.sync = true
+  end
+
+  def putc(byte)
+    @serial.putc(byte)
+  end
+end
+

data/test/printer_test.rb

@@ -0,0 +1,194 @@
+require "test_helper"
+require "printer"
+
+describe Printer do
+  def sent_bytes
+    @test_connection.bytes
+  end
+
+  before do
+    @test_connection = TestConnection.new
+    @printer = Printer.new(@test_connection)
+  end
+
+  it "can be reset" do
+    @printer.reset
+    sent_bytes.must_equal [27, 64]
+  end
+
+  it "prints a test page" do
+    @printer.test_page
+    sent_bytes.must_equal [18, 84]
+  end
+
+  it "can be flushed" do
+    @printer.flush
+    sent_bytes.must_equal [12]
+  end
+
+  it "can be set offline" do
+    @printer.offline
+    sent_bytes.must_equal [27, 61, 0]
+  end
+
+  it "can be set offline" do
+    @printer.online
+    sent_bytes.must_equal [27, 61, 1]
+  end
+
+  describe "feeding" do
+    it "feeds a single line" do
+      @printer.feed
+      sent_bytes.must_equal [10]
+    end
+
+    it "feeds multiple lines" do
+      @printer.feed(3)
+      sent_bytes.must_equal [10, 10, 10]
+    end
+  end
+
+  describe "initializing" do
+    it "resets the print settings" do
+      @printer.begin(100)
+      sent_bytes.must_equal [
+        27, 64, # reset
+        27, 55, # start control parameter command
+                7, # dots
+                100, # heat time
+                50, # heat interval
+        18, 35, # start print density command
+                (15 << 4) | 15 # print density
+      ]
+    end
+
+    it "sets the defaults" do
+      @printer.expects(:online)
+      @printer.expects(:justify).with(:left)
+      @printer.expects(:normal)
+      @printer.expects(:underline_off)
+      @printer.expects(:set_line_height).with(32)
+      @printer.set_default
+    end
+  end
+
+  describe "printing characters" do
+    it "sends the characters as bytes" do
+      @printer.print("hello")
+      sent_bytes.must_equal %w(h e l l o).map(&:ord)
+    end
+
+    it "sends a newline character when printing with println" do
+      @printer.println("hello")
+      sent_bytes.must_equal %w(h e l l o).map(&:ord) + [10]
+    end
+  end
+
+  describe "printing bitmaps" do
+    describe "shorter than 255 rows" do
+      before do
+        @printer.print_bitmap(width=8, height=8, [1,2,3,4,5,6,7,8])
+      end
+
+      it "writes the prefix" do
+        sent_bytes[0,2].must_equal [18, 42]
+      end
+
+      it "writes the number of rows of the bitmap" do
+        sent_bytes[2,1].must_equal [8]
+      end
+
+      it "writes the width of the bitmap in bytes" do
+        sent_bytes[3,1].must_equal [1]
+      end
+
+      it "writes the bitmap data" do
+        sent_bytes[4..-1].must_equal [1,2,3,4,5,6,7,8]
+      end
+    end
+
+    describe "longer than 255 rows" do
+      before do
+        @printer.print_bitmap(width=8, height=256, [3]*256)
+      end
+
+      it "writes the prefix" do
+        sent_bytes[0,2].must_equal [18, 42]
+      end
+
+      it "writes the number of rows of the first bitmap chunk" do
+        sent_bytes[2,1].must_equal [255]
+      end
+
+      it "writes the width of the bitmap in bytes" do
+        sent_bytes[3,1].must_equal [1]
+      end
+
+      it "writes the first chunk of bitmap data" do
+        sent_bytes[4,255].must_equal [3] * 255
+      end
+
+      it "writes the prefix a second time" do
+        sent_bytes[259,2].must_equal [18, 42]
+      end
+
+      it "writes the number of rows of the second bitmap chunk" do
+        sent_bytes[261,1].must_equal [1]
+      end
+
+      it "writes the width of the bitmap in bytes" do
+        sent_bytes[262,1].must_equal [1]
+      end
+
+      it "writes the second chunk of bitmap data" do
+        sent_bytes[263..-1].must_equal [3]
+      end
+    end
+
+    describe "from an IO object" do
+      before do
+        data = StringIO.new(([3]*8).map(&:chr).join)
+        @printer.print_bitmap(width=8, height=8, data)
+      end
+
+      it "writes the prefix" do
+        sent_bytes[0,2].must_equal [18, 42]
+      end
+
+      it "writes the number of rows of the bitmap" do
+        sent_bytes[2,1].must_equal [8]
+      end
+
+      it "writes the width of the bitmap in bytes" do
+        sent_bytes[3,1].must_equal [1]
+      end
+
+      it "writes the bitmap data" do
+        sent_bytes[4..-1].must_equal [3,3,3,3,3,3,3,3]
+      end
+    end
+
+    describe "where width and height aren't given" do
+      before do
+        data = StringIO.new(([8,0,8,0] + [3]*8).map(&:chr).join)
+        @printer.print_bitmap(data)
+      end
+
+      it "writes the prefix" do
+        sent_bytes[0,2].must_equal [18, 42]
+      end
+
+      it "writes the number of rows of the bitmap" do
+        sent_bytes[2,1].must_equal [8]
+      end
+
+      it "writes the width of the bitmap in bytes" do
+        sent_bytes[3,1].must_equal [1]
+      end
+
+      it "writes the bitmap data" do
+        sent_bytes[4..-1].must_equal [3,3,3,3,3,3,3,3]
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,18 @@
+require "minitest/autorun"
+require "rubygems"
+require "bundler"
+Bundler.require(:default, :test)
+require "mocha"
+
+$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+
+class TestConnection
+  attr_reader :bytes
+  def initialize
+    @bytes = []
+  end
+  def putc(byte)
+    @bytes << byte
+  end
+end
+    

metadata

@@ -0,0 +1,55 @@
+--- !ruby/object:Gem::Specification
+name: printer
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- James Adam
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-06 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: james@lazyatom.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- test/printer_test.rb
+- test/test_helper.rb
+- lib/printer.rb
+- lib/serial_connection.rb
+homepage: http://lazyatom.com
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3514750495519384979
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -3514750495519384979
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Sending commands to a small thermal printer
+test_files: []