Adafruit_Thermal.py

#*************************************************************************
# This is a MicroPython library for the Adafruit Thermal Printer, based on
# Python library by Adafruit. For more info and troubleshooting see the
# README and the original repo at:
# 	https://github.com/adafruit/Python-Thermal-Printer
#
# Tested with LoPy v1.
# The RX pin functionality was not tested.
#
# MicroPython port by Dominik Kapusta.
#*************************************************************************
# This is a Python library for the Adafruit Thermal Printer.
# Pick one up at --> http://www.adafruit.com/products/597
# These printers use TTL serial to communicate, 2 pins are required.
# IMPORTANT: On 3.3V systems (e.g. Raspberry Pi), use a 10K resistor on
# the RX pin (TX on the printer, green wire), or simply leave unconnected.
#
# Adafruit invests time and resources providing this open source code.
# Please support Adafruit and open-source hardware by purchasing products
# from Adafruit!
#
# Written by Limor Fried/Ladyada for Adafruit Industries.
# Python port by Phil Burgess for Adafruit Industries.
# MIT license, all text above must be included in any redistribution.
#*************************************************************************

# This is pretty much a 1:1 direct Python port of the Adafruit_Thermal
# library for Arduino.  All methods use the same naming conventions as the
# Arduino library, with only slight changes in parameter behavior where
# needed.  This should simplify porting existing Adafruit_Thermal-based
# printer projects to Raspberry Pi, BeagleBone, etc.  See printertest.py
# for an example.
#
# One significant change is the addition of the printImage() function,
# which ties this to the Python Imaging Library and opens the door to a
# lot of cool graphical stuff!
#
# TO DO:
# - Might use standard ConfigParser library to put thermal calibration
#   settings in a global configuration file (rather than in the library).
# - Make this use proper Python library installation procedure.
# - Trap errors properly.  Some stuff just falls through right now.
# - Add docstrings throughout!

from machine import UART
import utime
import sys

class BitmapHeader:
    SIZE_IN_BYTES = 14

    def __init__(self, bytes):
        if len(bytes) != 14:
            raise ValueError

        if bytes[0:2] != b'BM':
            raise ValueError

        self.file_size = int.from_bytes(bytes[2:6], 'little')
        self.data_offset = int.from_bytes(bytes[-4:], 'little')


class BitmapHeaderInfo:
    SIZE_IN_BYTES = 40

    def __init__(self, bytes):
        if len(bytes) != 40:
            raise ValueError
        if int.from_bytes(bytes[12:14], 'little') != 1:
            raise ValueError # planes
        if int.from_bytes(bytes[14:16], 'little') != 1:
            raise ValueError # bit-depth
        if int.from_bytes(bytes[16:20], 'little') != 0:
            raise ValueError # compression
        if int.from_bytes(bytes[32:36], 'little') > 1:
            raise ValueError # we accept at most 1 color
        if int.from_bytes(bytes[36:40], 'little') > 1:
            raise ValueError # we accept at most 1 significant color

        self.width = int.from_bytes(bytes[4:8], 'little')
        self.height = int.from_bytes(bytes[8:12], 'little')

        self.width_in_bytes = int((self.width+7)/8)
        padding = (4 - int(self.width_in_bytes % 4)) % 4

        self.line_width = self.width_in_bytes + padding
        self.width_padding = (self.width_in_bytes + padding) * 8 - self.width
        self.last_byte_padding = self.width_in_bytes * 8 - self.width

        self.data_size = int.from_bytes(bytes[20:24], 'little')
        self.ppm_x = int.from_bytes(bytes[24:28], 'little')
        self.ppm_y = int.from_bytes(bytes[28:32], 'little')


class Adafruit_Thermal:

	resumeTime          =   0.0
	byteTime            =   0
	dotPrintTime        =   0.0
	dotFeedTime         =   0.0
	prevByte            =  '\n'
	column              =     0
	maxColumn           =    32
	charHeight          =    24
	lineSpacing         =     8
	barcodeHeight       =    50
	printMode           =     0
	defaultHeatDots     =    11
	defaultHeatTime     =   120
	defaultHeatInterval =    40
	baudrate            =  9600
	pins                = None

	def __init__(self, bus=1, baudrate=9600, pins=None, **kwargs):
		# Fallback to regular +,- operator in case 
		# utime.ticks_add and/or utime.ticks_diff are unavailable.
		self.ticks_diff = utime.ticks_diff if hasattr(utime, 'ticks_diff') else lambda x, y: x - y
		self.ticks_add = utime.ticks_add if hasattr(utime, 'ticks_add') else lambda x, y: x + y

		# Calculate time to issue one byte to the printer.
		# 11 bits (not 8) to accommodate idle, start and
		# stop bits.  Idle time might be unnecessary, but
		# erring on side of caution here.
		self.byteTime = round((11 / baudrate) * 1000)  # ms

		self.baudrate = baudrate

		# ESP8266 doesn't support pins parameter
		extra_options = {}
		if pins is not None:
			extra_options['pins'] = pins

		self.uart = UART(bus, baudrate=baudrate, stop=1, **extra_options)

		# Remainder of this method was previously in begin()

		# The printer can't start receiving data immediately
		# upon power up -- it needs a moment to cold boot
		# and initialize.  Allow at least 1/2 sec of uptime
		# before printer can receive data.
		self.timeoutSet(500)

		# Description of print settings from p. 23 of manual:
		# ESC 7 n1 n2 n3 Setting Control Parameter Command
		# Decimal: 27 55 n1 n2 n3
		# max heating dots, heating time, heating interval
		# n1 = 0-255 Max heat dots, Unit (8dots), Default: 7 (64 dots)
		# n2 = 3-255 Heating time, Unit (10us), Default: 80 (800us)
		# n3 = 0-255 Heating interval, Unit (10us), Default: 2 (20us)
		# The more max heating dots, the more peak current
		# will cost when printing, the faster printing speed.
		# The max heating dots is 8*(n1+1).  The more heating
		# time, the more density, but the slower printing
		# speed.  If heating time is too short, blank page
		# may occur.  The more heating interval, the more
		# clear, but the slower printing speed.

		heatDots = kwargs.get('heatdots', self.defaultHeatDots)
		heatTime = kwargs.get('heattime', self.defaultHeatTime)
		heatInterval = kwargs.get('heatinterval', self.defaultHeatInterval)
		self.writeBytes(
		  27,           # Esc
		  55,           # 7 (print settings)
		  heatDots,     # Heat dots
		  heatTime,     # Lib default
		  heatInterval) # Heat interval

		# Description of print density from p. 23 of manual:
		# DC2 # n Set printing density
		# Decimal: 18 35 n
		# D4..D0 of n is used to set the printing density.
		# Density is 50% + 5% * n(D4-D0) printing density.
		# D7..D5 of n is used to set the printing break time.
		# Break time is n(D7-D5)*250us.
		# (Unsure of default values -- not documented)

		printDensity   = 10 # 100%
		printBreakTime =  2 # 500 uS

		self.writeBytes(
		  18, # DC2
		  35, # Print density
		  (printBreakTime << 5) | printDensity)
		self.dotPrintTime = 30
		self.dotFeedTime  = 2

	# Because there's no flow control between the printer and computer,
	# special care must be taken to avoid overrunning the printer's
	# buffer.  Serial output is throttled based on serial speed as well
	# as an estimate of the device's print and feed rates (relatively
	# slow, being bound to moving parts and physical reality).  After
	# an operation is issued to the printer (e.g. bitmap print), a
	# timeout is set before which any other printer operations will be
	# suspended.  This is generally more efficient than using a delay
	# in that it allows the calling code to continue with other duties
	# (e.g. receiving or decoding an image) while the printer
	# physically completes the task.

	# Sets estimated completion time for a just-issued task.
	def timeoutSet(self, x):
		self.resumeTime = self.ticks_add(utime.ticks_ms(), x)

	# Waits (if necessary) for the prior task to complete.
	def timeoutWait(self):
		while self.ticks_diff(utime.ticks_ms(), self.resumeTime) < 0: pass

	# Printer performance may vary based on the power supply voltage,
	# thickness of paper, phase of the moon and other seemingly random
	# variables.  This method sets the times (in microseconds) for the
	# paper to advance one vertical 'dot' when printing and feeding.
	# For example, in the default initialized state, normal-sized text
	# is 24 dots tall and the line spacing is 32 dots, so the time for
	# one line to be issued is approximately 24 * print time + 8 * feed
	# time.  The default print and feed times are based on a random
	# test unit, but as stated above your reality may be influenced by
	# many factors.  This lets you tweak the timing to avoid excessive
	# delays and/or overrunning the printer buffer.
	def setTimes(self, p, f):
		# Units are in microseconds for
		# compatibility with Arduino library
		self.dotPrintTime = p / 1000000.0
		self.dotFeedTime  = f / 1000000.0

	# 'Raw' byte-writing method
	def writeBytes(self, *args):
		self.timeoutWait()
		self.timeoutSet(len(args) * self.byteTime)
		self.uart.write(bytes(args))

	# Override write() method to keep track of paper feed.
	def write(self, *data):
		for char in data:
			if char != 0x13:
				self.timeoutWait()
				self.uart.write(char)
				d = self.byteTime
				if ((char == '\n') or
				    (self.column == self.maxColumn)):
					# Newline or wrap
					if self.prevByte == '\n':
						# Feed line (blank)
						d += ((self.charHeight +
						       self.lineSpacing) *
						      self.dotFeedTime)
					else:
						# Text line
						d += int(((self.charHeight *
						       self.dotPrintTime) +
						      (self.lineSpacing *
						       self.dotFeedTime)))
						self.column = 0
						# Treat wrap as newline
						# on next pass
						char = '\n'
				else:
					self.column += 1
				self.timeoutSet(d)
				self.prevByte = char

	# The bulk of this method was moved into __init__,
	# but this is left here for compatibility with older
	# code that might get ported directly from Arduino.
	def begin(self, heatTime=defaultHeatTime):
		self.writeBytes(
		  27,       # Esc
		  55,       # 7 (print settings)
		  11,       # Heat dots
		  heatTime,
		  40)       # Heat interval

	def reset(self):
		self.writeBytes(27, 64) # Esc @ = init command
		self.prevByte      = '\n' # Treat as if prior line is blank
		self.column        =  0
		self.maxColumn     = 32
		self.charHeight    = 24
		self.lineSpacing   =  6
		self.barcodeHeight = 50
		# Configure tab stops
		self.writeBytes(27, 68)         # Set tab stops
		self.writeBytes( 4,  8, 12, 16) # every 4 columns,
		self.writeBytes(20, 24, 28,  0) # 0 is end-of-list.

	# Reset text formatting parameters.
	def setDefault(self):
		self.online()
		self.justify('L')
		self.inverseOff()
		self.doubleHeightOff()
		self.setLineHeight(30)
		self.boldOff()
		self.underlineOff()
		self.setBarcodeHeight(50)
		self.setSize('s')
		self.setCharset()
		self.setCodePage()

	def test(self):
		self.write("Hello world!")
		self.feed(2)

	def testPage(self):
		self.writeBytes(18, 84)
		self.timeoutSet(
		  self.dotPrintTime * 24 * 26 +
		  self.dotFeedTime * (6 * 26 + 30))

	def setBarcodeHeight(self, val=50):
		if val < 1: val = 1
		self.barcodeHeight = val
		self.writeBytes(29, 104, val)

	UPC_A   =  0
	UPC_E   =  1
	EAN13   =  2
	EAN8    =  3
	CODE39  =  4
	I25     =  5
	CODEBAR =  6
	CODE93  =  7
	CODE128 =  8
	CODE11  =  9
	MSI     = 10
	ITF     = 11
	CODABAR = 12

	def printBarcode(self, text, type):

		upcCodes = { # UPC codes & values for firmwareVersion >= 264
			self.UPC_A   : 65,
			self.UPC_E   : 66,
			self.EAN13   : 67,
			self.EAN8    : 68,
			self.CODE39  : 69,
			self.ITF     : 70,
			self.CODABAR : 71,
			self.CODE93  : 72,
			self.CODE128 : 73,
			self.I25     : -1, # NOT IN NEW FIRMWARE
			self.CODEBAR : -1,
			self.CODE11  : -1,
			self.MSI     : -1
		}

		n = upcCodes[type]
		if n == -1: return
		self.feed(1) # Recent firmware requires this?
		self.writeBytes(
		  29,  72, 2, # Print label below barcode
		  29, 119, 3, # Barcode width
		  29, 107, n) # Barcode type
		self.timeoutWait()
		self.timeoutSet((self.barcodeHeight + 40) * self.dotPrintTime)
		# Print string: write length byte + string sans NUL
		n = len(text)
		if n > 255: n = 255
		self.uart.write(chr(n))
		self.uart.write(text)
		self.prevByte = '\n'

	# === Character commands ===

	UPDOWN_MASK        = (1 << 2)
	BOLD_MASK          = (1 << 3)
	DOUBLE_HEIGHT_MASK = (1 << 4)
	DOUBLE_WIDTH_MASK  = (1 << 5)
	STRIKE_MASK        = (1 << 6)

	def setPrintMode(self, mask):
		self.printMode |= mask
		self.writePrintMode()
		if self.printMode & self.DOUBLE_HEIGHT_MASK:
			self.charHeight = 48
		else:
			self.charHeight = 24
		if self.printMode & self.DOUBLE_WIDTH_MASK:
			self.maxColumn  = 16
		else:
			self.maxColumn  = 32

	def unsetPrintMode(self, mask):
		self.printMode &= ~mask
		self.writePrintMode()
		if self.printMode & self.DOUBLE_HEIGHT_MASK:
			self.charHeight = 48
		else:
			self.charHeight = 24
		if self.printMode & self.DOUBLE_WIDTH_MASK:
			self.maxColumn  = 16
		else:
			self.maxColumn  = 32

	def writePrintMode(self):
		self.writeBytes(27, 33, self.printMode)

	def normal(self):
		self.printMode = 0
		self.writePrintMode()

	def inverseOn(self):
		self.writeBytes(29, 66, 1)

	def inverseOff(self):
		self.writeBytes(29, 66, 0)

	def upsideDownOn(self):
		self.setPrintMode(self.UPDOWN_MASK)

	def upsideDownOff(self):
		self.unsetPrintMode(self.UPDOWN_MASK)

	def doubleHeightOn(self):
		self.setPrintMode(self.DOUBLE_HEIGHT_MASK)

	def doubleHeightOff(self):
		self.unsetPrintMode(self.DOUBLE_HEIGHT_MASK)

	def doubleWidthOn(self):
		self.setPrintMode(self.DOUBLE_WIDTH_MASK)

	def doubleWidthOff(self):
		self.unsetPrintMode(self.DOUBLE_WIDTH_MASK)

	def strikeOn(self):
		self.setPrintMode(self.STRIKE_MASK)

	def strikeOff(self):
		self.unsetPrintMode(self.STRIKE_MASK)

	def boldOn(self):
		self.setPrintMode(self.BOLD_MASK)

	def boldOff(self):
		self.unsetPrintMode(self.BOLD_MASK)

	def justify(self, value):
		c = value.upper()
		if   c == 'C':
			pos = 1
		elif c == 'R':
			pos = 2
		else:
			pos = 0
		self.writeBytes(0x1B, 0x61, pos)

	# Feeds by the specified number of lines
	def feed(self, x=1):
		self.writeBytes(27, 100, x)
		self.timeoutSet(self.dotFeedTime * self.charHeight)
		self.prevByte = '\n'
		self.column   =    0

	# Feeds by the specified number of individual pixel rows
	def feedRows(self, rows):
		self.writeBytes(27, 74, rows)
		self.timeoutSet(rows * dotFeedTime)
		self.prevByte = '\n'
		self.column = 0

	def flush(self):
		self.writeBytes(12) # ASCII FF

	def setSize(self, value):
		c = value.upper()
		if c == 'L':   # Large: double width and height
			size            = 0x11
			self.charHeight = 48
			self.maxColumn  = 16
		elif c == 'M': # Medium: double height
			size            = 0x01
			self.charHeight = 48
			self.maxColumn  = 32
		else:          # Small: standard width and height
			size            = 0x00
			self.charHeight = 24
			self.maxColumn  = 32

		self.writeBytes(29, 33, size)
		prevByte = '\n' # Setting the size adds a linefeed

	# Underlines of different weights can be produced:
	# 0 - no underline
	# 1 - normal underline
	# 2 - thick underline
	def underlineOn(self, weight=1):
		if weight > 2: weight = 2
		self.writeBytes(27, 45, weight)

	def underlineOff(self):
		self.writeBytes(27, 45, 0)

	def printBitmap(self, w, h, bitmap, LaaT=False):
		rowBytes = int((w + 7) / 8)  # Round up to next byte boundary
		if rowBytes >= 48:
			rowBytesClipped = 48  # 384 pixels max width
		else:
			rowBytesClipped = rowBytes

		# if LaaT (line-at-a-time) is True, print bitmaps
		# scanline-at-a-time (rather than in chunks).
		# This tends to make for much cleaner printing
		# (no feed gaps) on large images...but has the
		# opposite effect on small images that would fit
		# in a single 'chunk', so use carefully!
		if LaaT: maxChunkHeight = 1
		else:    maxChunkHeight = 50 # lower max chunk (not 255) for memory-constrained systems (LoPy v1)

		i = 0
		for rowStart in range(0, h, maxChunkHeight):
			chunkHeight = h - rowStart
			if chunkHeight > maxChunkHeight:
				chunkHeight = maxChunkHeight

			# Timeout wait happens here
			self.writeBytes(18, 42, chunkHeight, rowBytesClipped)

			for y in range(chunkHeight):
				line = bitmap[i:i+rowBytesClipped]
				self.timeoutWait()
				self.timeoutSet(len(line) * self.dotPrintTime)
				self.uart.write(bytearray(line))
				i += rowBytes

		self.prevByte = '\n'

	def printBitmapFromFile(self, w, h, filename, LaaT=False):
		rowBytes = int((w + 7) / 8)  # Round up to next byte boundary
		if rowBytes >= 48:
			rowBytesClipped = 48  # 384 pixels max width
		else:
			rowBytesClipped = rowBytes

		# if LaaT (line-at-a-time) is True, print bitmaps
		# scanline-at-a-time (rather than in chunks).
		# This tends to make for much cleaner printing
		# (no feed gaps) on large images...but has the
		# opposite effect on small images that would fit
		# in a single 'chunk', so use carefully!
		if LaaT: maxChunkHeight = 1
		else:    maxChunkHeight = 50 # lower max chunk (not 255) for memory-constrained systems (LoPy v1)

		try:
			with open(filename, 'rb') as bitmap_file:
				i = 0
				for rowStart in range(0, h, maxChunkHeight):
					chunkHeight = h - rowStart
					if chunkHeight > maxChunkHeight:
						chunkHeight = maxChunkHeight

					# Timeout wait happens here
					self.writeBytes(18, 42, chunkHeight, rowBytesClipped)

					for y in range(chunkHeight):
						line = bytearray(bitmap_file.read(rowBytesClipped))
						self.timeoutWait()
						self.timeoutSet(rowBytesClipped * self.dotPrintTime)
						self.uart.write(line)
						i += rowBytes
						bitmap_file.seek(i)

				self.prevByte = '\n'

		except OSError as e:
			print('file access error: {}'.format(e.errno))


	def printBMPImage(self, filename, LaaT=False):
		try:
			with open(filename, 'rb') as bmp_file:
				header = BitmapHeader(bmp_file.read(BitmapHeader.SIZE_IN_BYTES))
				header_info = BitmapHeaderInfo(bmp_file.read(BitmapHeaderInfo.SIZE_IN_BYTES))

				data_end = header.file_size - 2

				if header_info.width_in_bytes >= 48:
					rowBytesClipped = 48  # 384 pixels max width
				else:
					rowBytesClipped = header_info.width_in_bytes

				# if LaaT (line-at-a-time) is True, print bitmaps
				# scanline-at-a-time (rather than in chunks).
				# This tends to make for much cleaner printing
				# (no feed gaps) on large images...but has the
				# opposite effect on small images that would fit
				# in a single 'chunk', so use carefully!
				if LaaT: maxChunkHeight = 1
				else:    maxChunkHeight = 50 # lower max chunk (not 255) for memory-constrained systems (LoPy v1)

				for startRow in range(0, header_info.height, maxChunkHeight):
					chunkHeight = header_info.height - startRow
					if chunkHeight > maxChunkHeight:
						chunkHeight = maxChunkHeight

					# Timeout wait happens here
					self.writeBytes(18, 42, chunkHeight, rowBytesClipped)
					for row in range(startRow + 1, startRow + 1 + chunkHeight):
						# seek to beginning of line
						bmp_file.seek(data_end - row * header_info.line_width)

						# read the whole line
						if header_info.last_byte_padding == 0 or header_info.width_in_bytes <= rowBytesClipped:
							line = bytearray(bmp_file.read(rowBytesClipped))
							self.timeoutWait()
							self.timeoutSet(self.dotPrintTime)
							self.uart.write(line)
						else:
							self.timeoutWait()
							self.timeoutSet(self.dotPrintTime)
							if rowBytesClipped > 1:
								line = bytearray(bmp_file.read(rowBytesClipped-1))
								self.uart.write(line)

							data = bmp_file.read(1)
							mask = 0xFF<<header_info.last_byte_padding & 0xFF
							self.uart.write(bytes([ord(data) & mask]))

				self.prevByte = '\n'

		except OSError as e:
			print('error: {}'.format(e))


	# Take the printer offline. Print commands sent after this
	# will be ignored until 'online' is called.
	def offline(self):
		self.writeBytes(27, 61, 0)

	# Take the printer online. Subsequent print commands will be obeyed.
	def online(self):
		self.writeBytes(27, 61, 1)

	# Put the printer into a low-energy state immediately.
	def sleep(self):
		self.sleepAfter(1) # Can't be 0, that means "don't sleep"

	# Put the printer into a low-energy state after
	# the given number of seconds.
	def sleepAfter(self, seconds):
		self.writeBytes(27, 56, min(seconds,0xFF))

	def wake(self):
		self.timeoutSet(0)
		self.writeBytes(255)
		utime.sleep_ms(50)            # 50 ms
		self.writeBytes(27, 56, 0) # Sleep off (important!)

	# Empty method, included for compatibility
	# with existing code ported from Arduino.
	def listen(self):
		pass

	# Check the status of the paper using the printers self reporting
	# ability. Doesn't match the datasheet...
	# Returns True for paper, False for no paper.
	def hasPaper(self):
		self.writeBytes(27, 118, 0)
		# Bit 2 of response seems to be paper status
		stat = ord(self.uart.read(1)) & 0b00000100
		# If set, we have paper; if clear, no paper
		return stat == 0

	def setLineHeight(self, val=32):
		if val < 24: val = 24
		self.lineSpacing = val - 24

		# The printer doesn't take into account the current text
		# height when setting line height, making this more akin
		# to inter-line spacing.  Default line spacing is 32
		# (char height of 24, line spacing of 8).
		self.writeBytes(27, 51, val)

	CHARSET_USA          =  0
	CHARSET_FRANCE       =  1
	CHARSET_GERMANY      =  2
	CHARSET_UK           =  3
	CHARSET_DENMARK1     =  4
	CHARSET_SWEDEN       =  5
	CHARSET_ITALY        =  6
	CHARSET_SPAIN1       =  7
	CHARSET_JAPAN        =  8
	CHARSET_NORWAY       =  9
	CHARSET_DENMARK2     = 10
	CHARSET_SPAIN2       = 11
	CHARSET_LATINAMERICA = 12
	CHARSET_KOREA        = 13
	CHARSET_SLOVENIA     = 14
	CHARSET_CROATIA      = 14
	CHARSET_CHINA        = 15

	# Alters some chars in ASCII 0x23-0x7E range; see datasheet
	def setCharset(self, val=0):
		if val > 15: val = 15
		self.writeBytes(27, 82, val)

	CODEPAGE_CP437       =  0 # USA, Standard Europe
	CODEPAGE_KATAKANA    =  1
	CODEPAGE_CP850       =  2 # Multilingual
	CODEPAGE_CP860       =  3 # Portuguese
	CODEPAGE_CP863       =  4 # Canadian-French
	CODEPAGE_CP865       =  5 # Nordic
	CODEPAGE_WCP1251     =  6 # Cyrillic
	CODEPAGE_CP866       =  7 # Cyrillic #2
	CODEPAGE_MIK         =  8 # Cyrillic/Bulgarian
	CODEPAGE_CP755       =  9 # East Europe, Latvian 2
	CODEPAGE_IRAN        = 10
	CODEPAGE_CP862       = 15 # Hebrew
	CODEPAGE_WCP1252     = 16 # Latin 1
	CODEPAGE_WCP1253     = 17 # Greek
	CODEPAGE_CP852       = 18 # Latin 2
	CODEPAGE_CP858       = 19 # Multilingual Latin 1 + Euro
	CODEPAGE_IRAN2       = 20
	CODEPAGE_LATVIAN     = 21
	CODEPAGE_CP864       = 22 # Arabic
	CODEPAGE_ISO_8859_1  = 23 # West Europe
	CODEPAGE_CP737       = 24 # Greek
	CODEPAGE_WCP1257     = 25 # Baltic
	CODEPAGE_THAI        = 26
	CODEPAGE_CP720       = 27 # Arabic
	CODEPAGE_CP855       = 28
	CODEPAGE_CP857       = 29 # Turkish
	CODEPAGE_WCP1250     = 30 # Central Europe
	CODEPAGE_CP775       = 31
	CODEPAGE_WCP1254     = 32 # Turkish
	CODEPAGE_WCP1255     = 33 # Hebrew
	CODEPAGE_WCP1256     = 34 # Arabic
	CODEPAGE_WCP1258     = 35 # Vietnam
	CODEPAGE_ISO_8859_2  = 36 # Latin 2
	CODEPAGE_ISO_8859_3  = 37 # Latin 3
	CODEPAGE_ISO_8859_4  = 38 # Baltic
	CODEPAGE_ISO_8859_5  = 39 # Cyrillic
	CODEPAGE_ISO_8859_6  = 40 # Arabic
	CODEPAGE_ISO_8859_7  = 41 # Greek
	CODEPAGE_ISO_8859_8  = 42 # Hebrew
	CODEPAGE_ISO_8859_9  = 43 # Turkish
	CODEPAGE_ISO_8859_15 = 44 # Latin 3
	CODEPAGE_THAI2       = 45
	CODEPAGE_CP856       = 46
	CODEPAGE_CP874       = 47

	# Selects alt symbols for 'upper' ASCII values 0x80-0xFF
	def setCodePage(self, val=0):
		if val > 47: val = 47
		self.writeBytes(27, 116, val)

	# Copied from Arduino lib for parity; may not work on all printers
	def tab(self):
		self.writeBytes(9)
		self.column = (self.column + 4) & 0xFC

	# Copied from Arduino lib for parity; may not work on all printers
	def setCharSpacing(self, spacing):
		self.writeBytes(27, 32, spacing)

	# Overloading print() in Python pre-3.0 is dirty pool,
	# but these are here to provide more direct compatibility
	# with existing code written for the Arduino library.
	def print(self, *args, **kwargs):
		for arg in args:
			self.write(str(arg))

	# For Arduino code compatibility again
	def println(self, *args, **kwargs):
		for arg in args:
			self.write(str(arg))
		self.write('\n')