# Mini Thermal Receipt Printers
## Overview
Add printing to any microcontroller project with these very cute thermal printers. Also known as receipt printers, they’re what you see at the ATM or grocery store. Now you can embed a little printer of your own into a project. These printers is ideal for interfacing with a microcontroller, you simply need a 3.3V to 5V TTL serial output from your microcontroller to print text, barcodes, bitmap graphics, even a QR code!
These printers use very common 2.25" (58mm) wide thermal paper, available in the Adafruit shop or most office or stationery supply stores. You will also need a 5 Volt to 9 Volt regulated DC power supply that can provide 2 Amps or more during high-current printing — [our 5V 2A power supply will work very nicely](https://www.adafruit.com/products/276).
**[You can pick up a thermal printer pack including printer, paper, power supply and terminal-block adapter in the Adafruit shop!](http://www.adafruit.com/products/600 "Link: http://www.adafruit.com/products/600")**
Of course, we wouldn't leave you with a datasheet and a “good luck!” — this tutorial and matching Arduino library demonstrate the following:
- Printing with small, medium and large text
- **Bold,** underline and inverted text
- Variable line spacing
- Left, center and right justification
- Barcodes in the following standard formats: **UPC A, UPC E, EAN13, EAN8, CODE39, I25, CODEBAR, CODE93, CODE128, CODE11** and **MSI** - with adjustable barcode height
- Custom monochrome bitmap graphics
- How to print a QR code
## Models
Our _[**Mini Thermal Receipt Printer**](https://www.adafruit.com/product/597)_ is a popular choice as it accommodates a [full-length thermal roll (15m/50')](https://www.adafruit.com/product/599), meaning fewer paper changes. It’s also available in a [**starter pack**](https://www.adafruit.com/product/600) that includes a 5V power supply and DC jack adapter.
This model has a **3-pin serial interface** for connecting to 3.3V or 5V microcontrollers or Raspberry Pi.
The [_ **Tiny Thermal Receipt Printer** _](https://www.adafruit.com/product/2751) is a bit more compact, accommodating shorter [10m/33' rolls](https://www.adafruit.com/product/2754).
What’s interesting and **unique to this model** is that it has _both_ a 5-pin serial header and a **USB port** , which can make for easier interfacing on Raspberry Pi.
For the most compact and portable situations, the [_ **Nano Thermal Receipt Printer** _](https://www.adafruit.com/product/2752) is smaller still, accommodating a [5m/16' paper roll](https://www.adafruit.com/product/2755).
This one has a **5-pin header** for serial data and power.
For the most peculiar situations not covered above, the [_ **Thermal Printer Receipt Guts** _](https://www.adafruit.com/product/2753) is _just the insides_ of a thermal printer. You will need to design and build an enclosure to mount the hardware and hold a paper roll…in principle, _any length_ roll can then work with this.
This unit has a **5-pin header** for serial data and power.
The thermal paper rolls in the Adafruit shop are BPA-free and ready sized to each of the above units. You can also find compatible 2.25" (58mm) wide thermal paper at many office supply stores, though usually in 80–85 foot (25m) lengths that won’t fit as-is in any of these printers. With some patience you can re-roll these onto an empty spool, cutting when the roll reaches a suitable diameter.
**None of these small thermal printers have a cut feature; pull the finished print against the perforated edge.** The _Thermal Printer Guts_ has no perforated edge; you’ll need to design this into your enclosure.
Primary:
# Mini Thermal Receipt Printers
## Power
These printers use a thermal head to heat the special receipt paper and draw images and text. That makes them very small — there's no moving ink head — but it means they require a _lot_ of power: **5 to 9 Volts DC** , at least **2 Amps** of current. That means you will need a fairly beefy supply and you **cannot** run it off of USB power. An external adapter is _required!_
As a baseline, we suggest the [5V 2A power supply in our shop](http://www.adafruit.com/products/276). It provides sufficient power to keep the printer happy, and usually enough overhead to power a modest microcontroller project along with it.
A quick way to connect this to the printer’s red/black power wires is with a [2.1mm jack adapter](http://www.adafruit.com/products/368 "Link: http://www.adafruit.com/products/368"):
The 5V 2A supply mentioned above is a _baseline._ If using this, you might want to power the microcontroller separately through its USB port, to prevent a brownout condition when the printer is drawing a lot of current. Higher current supplies — [4 Amp](https://www.adafruit.com/product/1466) and [10 Amp](https://www.adafruit.com/product/658)\* — are also available in the shop, bulkier but with ample overhead for both the printer and supporting hardware you might be adding.
The higher current can make for darker printing and quicker, more assertive paper feed. Slightly higher _voltage_ can too — to a point. One should **never exceed 9 Volts** to the printer; 12V or more will permanently damage it! 2A (or more) current is still recommended at these higher voltages. If upcycling a power supply from something else, carefully check the polarity (most, _but not all,_ are “tip positive”) and that the output is DC, _not AC._
A benefit to 5V power is that many dev boards can run from this directly and will regulate to 3.3V if needed; only a single power source is needed. That’s not necessarily true with higher voltages…though some, like the Arduino Uno, _can_ accept 9V through the board’s DC power jack.
_\* The printer will never draw_ anywhere near _this much current, but larger supplies are less susceptible to voltage droop when there’s a sudden demand. Sometimes just a matter of what’s presently in stock without waiting, or what other projects you might want to use this with in the future (e.g. large NeoPixel projects could benefit from the extra capacity of a 4A or 10A 5V supply)._
The **Mini** thermal printer has two 3-pin sockets—one for power, one for serial communication. Power goes to the jack labeled “ **DC IN**.” Only the outer two pins of this connector are used.
The **Tiny** printer has three sockets: a **2-pin connector for power** , 5-pin for TTL serial communication, and a USB port.
DO NOT attempt powering from the red and black wires of the serial cable. This cable is _not_ following common electronics color conventions and connecting power here may damage the printer! Use ONLY the 2-pin connector for power.
The **Nano** printer and “printer guts” have a single 5-pin connector for power and serial data. The outermost **red** and **black** wires are for +V and ground, following typical conventions.
## Making the Power Connection
During initial testing and for quick temporary projects, it’s usually okay to jam [breadboard prototyping wires](https://www.adafruit.com/product/1956) into the end connector on the DC power cable (or power+serial cable on Nano and guts), and the other end to a DC barrel jack adapter.
However, breadboard wires are small gauge and not suited to continuous heavy power draw. Once you’re “moved in” — confident the printer works and will suffice for a project — one option is to cut the DC cable, strip the wire ends and screw these _directly_ to the DC barrel jack, without the breadboard wires as a go-between.
Keep the serial wires intact though. Breadboard wires work splendidly there.
The most robust option, if you want to get all _fancy,_ is to splice a DC jack pigtail to the power cable.
This is not a part we carry. One option is to cut a [DC barrel jack extension cable](https://www.adafruit.com/product/327) in half and use the socket end. Or, the pigtails are commonly used in security camera installations, so you might find something by searching around.
# Mini Thermal Receipt Printers
## First Test
The first test you should do will ensure that paper is loaded and power is wired up correctly and the printer is running.
First up, pull the little plastic tab up top to open up the paper holder. Then insert a roll of 58 millimeter (2 1/4 inch) thermal paper into the bay as shown in the image below.
To reiterate from the first page, the printer models and corresponding roll sizes are:
- **[Mini](https://www.adafruit.com/product/597):** [15m / 50 foot roll](https://www.adafruit.com/product/599)
- **[Tiny](https://www.adafruit.com/product/2751):** [10m / 33'](https://www.adafruit.com/product/2754)
- **[Nano](https://www.adafruit.com/product/2752):** [5m / 15'](https://www.adafruit.com/product/2755)
- **[Guts](https://www.adafruit.com/product/2753):** no paper bay; use any size roll
Make sure that the paper doesn't bind or stick in the bay, it should rotate freely.
As described on prior page, power the printer using a 5V to 9V 2A or higher power supply, such as wiring up a 2.1mm DC power jack:
## Print Test Page
Most of these thermal printers have a test feature providing basic diagnostics. You’ll then know that power is good, paper is correctly loaded, and have some configuration details of the particular unit.
On most **Mini** and **Tiny** printers: **hold down** the button on the top of the printer **while connecting power** to print a test page. In normal use, tapping this button feeds the paper by one line.
On most **Nano** printers and **printer guts** : **connect power first** , then **tap** the button on the control board to print a test page.
_Not all “printer guts” units have a button installed. If needed, you can make a temporary connection across the “J1” pads using a jumper wire or metal tweezers._
Occasional factory production changes occur…if you don’t get a test page using the method above for you model, try the opposite method. A few may even lack a test page feature, but the status LED provides an indication of good power.
Info:
If you don't get a printout, check that the paper is inserted correctly and not binding, that the power is correctly wired, power supply is plugged in, etc. Then try again.
Note the baud rate on the test page. This may be 19200 or 9600. We'll need this number later:
Info:
# Mini Thermal Receipt Printers
## Making Connections
These printers might see use with **microcontrollers** or with Linux-based computers such as **Raspberry Pi**. The **Tiny** printer has the distinct option of connecting to a Raspberry Pi’s **USB** port, covered later on this page. But to start, let’s talk about _ **TTL serial** _—the non-USB connection present across _all_ of these printers.
## TTL Serial
Most microcontrollers can provide a 3.3V or 5V _TTL serial connection_. It’s not same as the 10V RS232 serial from a computer’s 9-pin serial port — don’t connect the printer directly to a standard PC port or you may damage it. A _USB-to-serial cable_ (such as those made by FTDI, or similar) is an option on Linux PCs, but most will be using it with a microcontroller.
It **makes no difference** if the controller is a **5 Volt** or **3.3 Volt** device. The printer logic is 3.3V, but “5V tolerant,” meaning **no extra level-shifting circuitry is needed** in either direction. Some older documentation may still show a _voltage divider_ (two resistors and some extra wires), but that’s since been found unnecessary. The printer and 5V _or_ 3.3V devices can connect directly.
To start, we’ll connect to the data cable of the printer. Easiest is to simply press breadboard jumper wires into the data plug, then use those to extend the connection to the host: an Arduino or other microcontroller, Raspberry Pi, or USB-to-serial cable.
If the controller is on a **breadboard** or the **socket headers** along the edges of an Arduino Uno-like board, or with most **USB-to-serial** cables: **male/male** jumper wires are suitable.
If the controller is a **Raspberry Pi** : use **female/male** jumper wires to the Pi’s GPIO header.
The **wire color for each pin** is **_not_ the same** across all these printers. Please read the descriptions carefully. It’s _nice_ (but not _mandatory_) to match jumper wire colors to the printer’s data cable, to help keep track of things.
## For Product #597: “Mini”
The **Mini** printer data cable has three wires:
- Black = **GROUND** reference
- Yellow = data **IN** to the printer (RX)
- Green = data **OUT** of the printer (TX)
This is in addition to the separate power cable, described on the prior page.
## For Product #2751: “Tiny”
The **Tiny** printer data cable has **five** wires:
- Red = **GROUND** (yes, red, and yes this totally is the opposite of common electronics conventions)
- Green = data **IN** to the printer (RX)
- Blue = data **OUT** of the printer (TX)
- Yellow (DTR) and black can be left **unconnected**
This is in addition to the separate power cable, described on the prior page.
## For Product #2752: “Nano”
The **Nano** printer cable has **five** wires and _no_ separate power cable.
- Black = power _and_ signal **GROUND**
- Blue = data **IN** to the printer (RX)
- Green = data **OUT** of the printer (TX)
- Red = 5–9V DC power
- Yellow = DTR, can be left unconnected for now
Power and data share a single connector here. Ground must go to _both_ the power supply _and_ the microcontroller, meaning you’ll need a split here, perhaps using a breadboard’s power rail.
## For Product #2753: “Guts”
The **Printer Guts** cable has **five** wires and no separate power cable.
Some printers have a color-coded cable, while others have just have a plain white cable. Unplug this temporarily from the printer and you should find the pin functions **labeled on the PCB** :
The pin order here is **not the same** as the Tiny or Nano printers. And if you have both Guts and Nano printers, be _super careful_ about the wiring, because the plugs are interchangeable but the sequence of wires and colors (if any) _do not_ have the same functions!
- **VH** = 5–9V DC power
- **GND** = power _and_ signal **GROUND**
- **RX** on the PCB = data **IN** to the printer
- **TX** on the PCB = data **OUT** of the printer
- **DTR** on the PCB = can leave unconnected for now
As with the Nano printer, power and data share a single connector. Ground must go to _both_ the power supply _and_ the microcontroller, meaning you’ll need a split here, perhaps using a breadboard’s power rail.
## To Arduino
For a board like the **Arduino Uno** , the other end of the jumper wires can insert into the **board edge sockets**. For smaller devices on a **breadboard** , insert into the corresponding **contact strip**.
**Ground** from the printer always connects to **GND** on the microcontroller board. For the data wires ( **TX** and **RX** ), which pins to connect to can vary by hardware and software, explained further on subsequent pages. Some situations may require specific pins, but you can usually use any two pins. Here’s the printer’s TX line connected to digital pin 5, and RX to digital pin 6:
Warning:
## To Raspberry Pi
Before connecting any **TTL serial** printers to **Raspberry Pi** , it’s _vitally important_ to perform a little **system configuration** first.
The Raspberry Pi board has a TTL serial connection on the GPIO breakout header. By default, it’s configured for a _serial console_ — connected to a terminal, this provides another way to log into the system (along with Ethernet, WiFi or keyboard+monitor). We need to **turn off** the serial console behavior, or a connected printer will just spit out endless gibberish! This only applies to a **TTL serial** connection; **Tiny** printers using **USB** , or others when using a **USB-to-serial** adapter, don’t need this step.
If using a **desktop** OS (mouse and GUI), it’s just a few clicks. From the “Pi” menu at the top left, select **Preferences→Raspberry Pi Configuration…**
Select the **Interfaces** tab.
Turn **Serial Port _ON_** _,_ and **Serial Console _OFF_** _,_ as shown in the image.
Click the “ **OK** ” button, then “ **Yes** ” when asked whether to reboot
If a “ **lite** ” OS (text login), this is done from the command line:
```terminal
sudo raspi-config
```
You’ll find the Serial Port settings under “ **Interface Options**.” Select “ **No** ” for the login shell, and “ **Yes** ” if asked about the serial port hardware (this option might not show up on older Pi models, where it’s always on). Tab over to “ **Finish** ” and reboot when asked.
_Now_ the printer can be connected without making a mess.
The diagram at left shows the Pi’s GPIO header. For orientation reference, the 5V pin at the top right is nearest the corner of the board.
TX and TXD mean the same thing: _transmit_ or _transmit data._ Likewise with RX and RXD. The terms might get used interchangeably.
**TX** and **RX** from the printer go to specific GPIO pins with _opposite_ functions. TX to RX and RX to TX, known as a _crossover_ configuration:
Really you can use _any_ GND shown in the pinout diagram above. The third pin is easy to locate, but that spot’s sometimes occupied by other hardware like small cooling fans.
If you happen to be using the **Mini** printer with the 3-pin data cable, and if the Pi and printer are kept close together, you might not even need jumper wires. Skip the first two 5V pins on the GPIO header, and the data cable can press right on to the next 3 pins in sequence: GND, TX and RX.
## To USB-to-Serial Cable (FTDI, etc.)
The principle here is similar to Raspberry Pi above: create a _crossover_ by connecting the printer’s TX to the adapter cable’s RX pin, RX to TX, and ground to ground.
The diagram here is representative, not literal. Some adapter cables might have this pinout, but others will not. FTDI cables, for example, usually have a 6-pin header with its own color code; only 3 pins are needed here. You’ll find pin functions and colors in the specific cable’s documentation.
Any of these cables will require _device driver_ software. Popular ones (FTDI, Prolific, etc.) might already be present on Linux systems. Check documentation.
Also, _how_ the device manifests when connected to a computer’s USB port will vary among manufacturers and drivers. In Linux it might show as `/dev/tty.USBserial` (followed by a number), but other conventions are sometimes used. Skim through the `/dev` directory and/or try the `lsusb` command to help identify the device.
## “Tiny” Printer: USB to Linux (Raspberry Pi, etc.)
The **Tiny** printer has the lovely option of connecting via USB cable, no jumper wires needed. On Raspberry Pi, there’s _no need_ to change anything with raspi-config…but there _are_ some things to know about the system.
On current Tiny printers, and on earlier ones _when suitably configured,_ the printer appears to the system as **/dev/usb/lp0** and operates through the _USB printing subsystem._ Sometimes there will be a different number at the end, if more printers are attached.
On earlier Tiny printers, the factory configuration instead has it appear as **/dev/ttyUSB0** , which mimics a Prolific _USB-to-serial bridge. _Sometimes there will be a different number at the end, if other USB-to-serial devices are attached.
Any software or commands that want to issue data to the printer should speak to the appropriate device name (try `ls /dev` from the command line to see what’s present, or try `lsusb`). Project code will often have the system device name in a global variable somewhere. Aside from that difference, they should both function the same; open the device, issue data, printer prints it.
If you have an older Tiny printer (defaulting to _USB-to-serial bridge_) and specifically _require_ USB printing subsystem compatibility instead, there’s a way to switch it over:
1. Similar to the self-test, **hold** the **paper feed button** while applying power…but now _ **keep holding it.** _
2. After the QR code, the current USB mode is printed: this will either be **COM** (USB-to-serial mode, the default) or **Printable Port** (USB printing subsystem).
3. **Release** the paper feed button.
4. To **keep** the current setting, **tap** the paper feed button once more.
5. To **change** to to the opposite USB setting (COM or Printable Port), **hold** the feed button for at least **2 seconds**. The printer will confirm the change.
This is present only in older Tiny printers. Current units work strictly in USB printing subsystem mode—it’s considered more modern—and continuing to hold the paper feed button will just eject a lot of paper…so don’t.
# Mini Thermal Receipt Printers
## Arduino Code
Connections are explained on the prior page. For the Arduino example code, we’ll connect the printer’s data out (TX) wire to digital pin 5, and data in (RX) to digital pin 6. Ground can go to any Arduino GND pin. Pins are configurable, but this is what the example uses, so let’s stick with that for now.
On the Arduino side, pin 5 _receives_ (RX) and 6 _transmits_ (TX)…opposite of the printer’s pin functions…called a _crossover_ configuration, something you’ll hear a lot in serial communication and networking.
## Install Library
We made an [Arduino library to assist working with these printers](https://github.com/adafruit/Adafruit-Thermal-Printer-Library).
Go to the _Arduino Library Manager_ under **Sketch→Include…Library→Manage…Libraries…**
Search for and install the **Adafruit Thermal Printer** library:
We also have a great tutorial on Arduino library installation at:
[http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use](http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use "Link: http://learn.adafruit.com/adafruit-all-about-arduino-libraries-install-use")
You should now be able to access the sample code by navigating through menus in this order: **File→Sketchbook→Libraries→Adafruit\_Thermal→A\_printertest**
**If your printer test page shows 'BAUDRATE: 9600', you'll need to make a small change to the library source code.** Using a text editor (Notepad, etc.) open the file Adafruit\_Thermal.cpp and change this line:
```auto
#define BAUDRATE 19200
```
to this:
```auto
#define BAUDRATE 9600
```
Some printers arrive from the factory set for 19200 baud, but a few may be set to 9600. This will _not_ negatively impact the performance of your unit! The speed of the paper through the printer is already much less than this and you will not see any difference…it's strictly a data protocol issue of getting the microcontroller and printer communicating.
OK upload the sketch (with baudrate change if necessary) to the Arduino. You should see the printer print out the example receipt which includes all the capabilities of the library.
If this does not work, first check that the printer and Arduino are both powered, and that the data in, out and ground wires are properly connected to the Arduino.
# Mini Thermal Receipt Printers
## Printing Text
The thermal printer has a few handy things it can do, most of which are in the **A\_printertest** sketch. These are shown in the image above. In order, starting from the top:
- Inverted text: this is invoked by calling **inverseOn()** — you will get text that’s white-on-black instead of black-on-white. **inverseOff() **turns this off.
- Double height: this makes text thats extra tall, call **doubleHeightOn()** — likewise, turn off with **doubleHeightOff()**
- Left/Center/Right justified: this aligns text to the left or right edge of the page, or centered. You can set the alignment by calling **justify('R') **(for right-justified), **justify('C') **(for centered) or **justify('L') **(for left-justified). Left-justified is the default state.
- **Bold** text: makes it stand out a bit more, enable with **boldOn()** and turn off with **boldOff()**
- Underlined text: makes it stand out a bit more, enable with **underlineOn()** and turn off with **underlineOff()**
- Large/Medium/Small text: by default we use small, medium is twice as tall, large is twice as wide/tall. Set the size with **setSize('L')**, **setSize('M')** or **setSize('S')**
- Line spacing: you can change the space _between _lines of text by calling **setLineHeight()** where **numpix** is the number of pixels. The minimum is 24 (no extra space between lines), the default spacing is 32, and double-spaced text would be 64.
Look through the source of the A\_printertest sketch to see these used in context.
# Mini Thermal Receipt Printers
## Bitmap Printing
This printer can produce bitmaps, which can add a touch of class to a receipt with your logo or similar.
The first step is to get the image prepared. The printer can only do monochrome (1-bit) images, and the maximum width is 384 pixels. We suggest starting with a small bitmap (100 pixels or less on each side) and then experimenting to get the size and look you want.
A few steps are required to prepare an image for printing. For Windows users, there’s a nice graphical user interface for this. For Mac and Linux, different tools are used…not as visually slick, but they do the job well.
Danger:
## Windows
Use an image editing program to save your image as a 1-bit BMP — in Windows, the built-in **Paint** program will suffice.
Download, install and run **[LCD Assistant](http://en.radzio.dxp.pl/bitmap_converter/)**. This program is for Windows only but does a really fantastic job! Load the BMP file you previously generated (in Paint, etc.). The file must be in BMP format — the software won’t read PNG, GIF, etc. Then a couple of settings need to be adjusted…
First, in the “Byte orientation” section of the settings, select “Horizontal” (item A in the image above).
Second (item B above), you may need to change the Width setting. Because this software (and the thermal printer) handle images in horizontal groups of eight pixels, if the image width is not a multiple of 8, it will be truncated (cropped) to the nearest smaller 8-pixel boundary. For example, with the 75 pixel wide image above, the output will be cropped to only 72 pixels wide, losing some data from the right edge. To avoid this, **increase this number to the next multiple of 8** (that would be 80 for the example above), and the output will be padded with blank pixels to cover the gap. Remember the number you use here, you’ll need it later.
The image height does not need to be adjusted this way, only width.
Set the table name to something short but descriptive (e.g. “adalogo” above), then select Save Output from the File menu. Give the file a similarly brief but descriptive name, ending in “.h” (e.g. “adalogo.h”).
To get this file into your Arduino sketch, select “Add File…” from the Sketch menu. This will add a new tab to your code. Your original code is still there under the leftmost tab.
A couple of small changes are now needed in both tabs. First, at the top of the file containing the new table data, change “const unsigned char” to “static const uint8\_t PROGMEM” as shown below:
Next, in the tab containing the main body of your code, add an “include” statement to reference the new file:
```auto
#include "adalogo.h"
```
Check the **A\_printertest** example sketch if you’re not sure how to include the code properly.
You can now output the image by calling **printBitmap(width, height, tablename)**, where **width** and **height** are the dimensions of the image in pixels (if you changed the image width to a multiple of 8 as previously described, use that number, not the original image size), and **tablename** is the name of the array in the new tab (e.g. “adalogo” above).
Having a graphical user interface is nice, but some of these extra steps can be confusing and error-prone. If you prefer, the technique below for Mac and Linux works in Windows as well.
## Mac and Linux
The conversion tool for Mac and Linux doesn’t include a fancy GUI, but it works well and avoids several steps (and potential mis-steps). The source image doesn’t need to be in BMP format — most image formats can be read natively — and the output can be added to a sketch with no further editing. It works for Windows as well, if you’d rather use this method.
First, if you don’t already have the **Processing** language installed, [download it from processing.org](http://processing.org). Processing looks almost exactly like the Arduino IDE, but it’s for writing code for your normal computer, not a microcontroller. This can be a little confusing to first-timers, so if something doesn’t seem to compile, make sure you’re running code in the right environment: _Arduino_ for for the Arduino board, _Processing_ for your computer.
Danger:
The Adafruit\_Thermal library folder that you previously downloaded contains a sub-folder called **processing**. Inside that is a sketch called **bitmapImageConvert.pde**. Load this into Processing and press RUN (the triangle button).
You’ll be prompted to select an image using the system’s standard file selection dialog. The program runs for just a brief instant, and will create a new file alongside the original image file. For example, if you selected an image called “adalogo.png”, there will be a new file called “adalogo.h” in the same location. This file contains code to add to your Arduino sketch. You shouldn’t need to edit this file unless you want to change the variable names within.
To get this file into your Arduino sketch, select “Add File…” from the Sketch menu. This will add a new tab to your code. Your original code is still there under the leftmost tab.
Next, in the tab containing the main body of your code, add an “include” statement to reference the new file:
```auto
#include "adalogo.h"
```
Check the **A\_printertest** example sketch if you’re not sure how to include the code properly.
If the source image was called adalogo.png, then the resulting .h file (adalogo.h) will contain three values called adalogo\_width, adalogo\_height and adalogo\_data, which can be passed directly and in-order to the printBitmap() function, like this:
```auto
printBitmap(adalogo_width, adalogo_height, adalogo_data);
```
# Mini Thermal Receipt Printers
## Barcode Printing
Thermal printers are really good at printing barcodes! This printer supports 11 different codes - **UPC A, UPC E, EAN13, EAN8, CODE39, I25, CODEBAR, CODE93, CODE128, CODE11** and **MSI**. It only supports linear (1-D) barcodes, and can’t generate 2-D barcodes like QR codes (although there is a hack you can do, see below!) Barcodes are generated “on the fly,” which is nice — you can customize the height and data included quite easily.
You can make a barcode by calling **printBarcode("barcodedata", BARCODETYPE)**, where the first string is the data to encode (e.g. a UPC code) and **BARCODETYPE** can be **UPC\_A, UPC\_E, **** EAN13, EAN8, CODE39, I25, CODEBAR, CODE93, CODE128, CODE11 ** or ** MSI**.
Some barcodes are very restricted — you can only put in 12 numbers, no characters. Others are very flexible and take nearly any character input.[ Please check out the wikipedia list detailing kinds of barcodes ](http://en.wikipedia.org/wiki/Barcodes#Linear_barcodes "Link: http://en.wikipedia.org/wiki/Barcodes#Linear\_barcodes")to pick the right one for your application.
The available range of barcodes varies with the printer firmware revision. Check Adafruit\_Thermal.h for a list of codes.
It’s also possible to print QR codes, if you’re willing to pre-generate them. This might be handy if you want to, let’s say, include a URL on the receipt and the URL doesn’t change. [You can generate QR codes at many sites including this one.](http://qrcode.kaywa.com/ "Link: http://qrcode.kaywa.com/") Use the smallest QR code size. The image will be in PNG format, so if you’re using the Windows LCD Assistant tool you’ll need to convert it to BMP first (Windows Paint works for this). Then you can convert and embed this in your Arduino sketch as previously described.
# Mini Thermal Receipt Printers
## CircuitPython and Python
It's easy to use the thermal printer with CircuitPython (or Python [via the _Blinka_ library](https://circuitpython.org/blinka)) and the [Adafruit CircuitPython Thermal Printer](https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer) module. This module allows you to easily write Python code that controls the printer, like printing text and barcodes (note right now bitmap printing is **not** supported by CircuitPython code).
**Wiring is explained on the “Making Connections” page.**
On **Raspberry Pi** , a common choice is to use the board’s **GPIO** pins to connect to the printer’s **TTL serial** port. Also on Pi, and on most other **computer** (not microcontroller) situations, there’s the **USB port** on the Tiny printer, or using a **USB-to-serial** or FTDI cable. [Please visit the guide for CircuitPython on Linux to see whether your platform is supported](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux).
## CircuitPython Installation of Thermal Printer Library
If you're using a CircuitPython microcontroller, you'll need to install the [Adafruit CircuitPython Thermal Printer](https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer) library on your CircuitPython board.
First make sure you are running the [latest version of Adafruit CircuitPython](../../../../welcome-to-circuitpython/installing-circuitpython) for your board.
Next you'll need to install the necessary libraries to use the hardware--carefully follow the steps to find and install these libraries from [Adafruit's CircuitPython library bundle](https://github.com/adafruit/Adafruit_CircuitPython_Bundle). Our introduction guide has [a great page on how to install the library bundle](../../../../welcome-to-circuitpython/circuitpython-libraries) for both express and non-express boards.
You can also download the **adafruit\_thermal\_printer** folder from [its releases page on Github](https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer/releases).
Copy the **adafruit\_thermal\_printer** folder into the CircuitPython drive’s **lib** directory. Place the _whole folder itself_ there, _not_ the individual files within.
## Python Installation of Thermal Printer Library
If you're using a Raspberry Pi or other computer with Python, you'll need to install the Adafruit\_Blinka library that provides the CircuitPython support in Python. This may require verifying you are running Python 3. [Since each platform is a little different, and Linux changes often, please visit the CircuitPython on Linux guide to get your computer ready](https://learn.adafruit.com/circuitpython-on-raspberrypi-linux)!
Once that's done, from your command line run the following command:
```terminal
sudo pip3 install adafruit-circuitpython-thermal-printer
```
## Firmware Version and Baud Rate
Before you can use the printer module you must determine the firmware version and baud rate of the printer. This is easy to find out by printing a test page from the printer as described on the [“First Test” page](../../../../mini-thermal-receipt-printer/first-test), hold the printer button as power is applied. Print out the test page and take note of these values printed at the bottom:
- **Baudrate** - Remember this value, typically 19200 or 9600.
- **Version** - Take note of this value too, it's a value like 2.2, 2.64, 2.68, etc. You will use the version to pick the appropriate module for interacting with the printer.
## Usage
If you're using a CircuitPython microcontroller, [connect to the board's serial REPL ](../../../../welcome-to-circuitpython/the-repl)so you are at the CircuitPython **\>\>\>** prompt. If you're using a computer like the Raspberry Pi, bring up a REPL at the command prompt by typing `python3`. (On some systems, `python` may run Python 3 - just make sure you're not using Python 2, as it isn't supported.)
To demonstrate the usage of the sensor we'll initialize it and print some text from the REPL.
First you must import the necessary modules to initialize the hardware serial connection to the printer. These commands will vary depending on your hardware - choose the appropriate set:
```python
# On a CircuitPython microcontroller:
import board
import busio
uart = busio.UART(board.TX, board.RX, baudrate=19200)
```
```python
# On the Raspberry Pi with built-in UART:
import serial
uart = serial.Serial("/dev/serial0", baudrate=19200, timeout=3000)
```
```python
# On the Raspberry Pi with the USB-to-serial converter:
import serial
uart = serial.Serial("/dev/ttyUSB0", baudrate=19200, timeout=3000)
```
```auto
# On the Raspberry Pi with recent Tiny printers on USB:
import serial
uart = serial.Serial("/dev/usb/lp0", baudrate=19200, timeout=3000)
```
Notice the baud rate of the serial connection is specified with the **baudrate** keyword. For most printers they'll use a rate of 19200 baud, however other printers might be configured to use a different rate like 9600 baud. **Use the baud rate you saw printed on the test page of your printer!**
Also be aware CircuitPython currently requires bi-direction UART connections so even if you don't have the board RX pin hooked up (as recommended) you **must** keep the RX pin disconnected and ignore using it in your project.
## Create ThermalPrinter Class
Next you'll need to import the thermal printer module and call a function to get the right class depending on the version of your printer firmware. **Be sure you've found the exact version number for your printer by following the steps mentioned above and on the previous test page!**
```auto
import adafruit_thermal_printer
ThermalPrinter = adafruit_thermal_printer.get_printer_class(2.69)
```
Notice you call the `get_printer_class` function from within the `adafruit_thermal_printer` module. You must pass this function the version of the thermal printer that you're using and it will internally find the right class to import and use in your code. In this example we're specifying a printer with version 2.69 firmware, but be sure to specify your printer's version!
The result is a class which you can immediately initialize:
## Initialize ThermalPrinter
Now construct an instance of the `ThermalPrinter` class:
```auto
printer = ThermalPrinter(uart)
```
Notice you must pass in the serial UART connection that was previously constructed.
Be aware it will take from a half to even 5 seconds for the printer to be created and initialize itself and warm up. You can optionally specify `auto_warm_up=False` as a keyword and manually call the `warm_up` function to control when this warm-up time occurs if needed in your application (or you are confused why your code takes so long to start up).
## Test Page Print
Now you're ready to print!
Try printing a full test page with the `test_page` function:
```auto
printer.test_page()
```
You should see the printer test page print out.
You can advance the paper forward a number of lines with the `feed` function, try feeding 2 lines to make some space:
```auto
printer.feed(2)
```
Now print a small line of text with the `print` function and feed a few lines to move it out of the printer to read:
```auto
printer.print('Hello from CircuitPython!')
printer.feed(2)
```
## Printer Fonts
There are a few properties you can use to adjust how text is printed. Each of these can be set to a `True` value to enable, or a `False` value to disable:
- `bold` - Print bold text.
- `inverse` - Print inverted (white on black) text.
- `upside_down` - Print upside down text (might not work on all versions of printers).
- `double_height` - Double height size text.
- `double_width` - Double width size text.
- `strike` - Strike-through text (again might not work on all versions of printers).
Try turning on bold text and printing a line:
```auto
printer.bold = True # Turn on bold
printer.print('This is bold text!')
printer.bold = False # Turn off bold
# Feed lines to make visible:
printer.feed(2)
```
There are a few properties you can set to special values to further control text printing:
- `underline` - This controls underline printing and can be None (off), `adafruit_thermal_printer.UNDERLINE_THIN`, or `adafruit_thermal_printer.UNDERLINE_THICK`.
- `size` **-** This controls the size of text and can be `adafruit_thermal_printer.SIZE_SMALL` **,** `adafruit_thermal_printer.SIZE_MEDIUM` **,** or` adafruit_thermal_printer.SIZE_LARGE` **. ** The default is small.
- `justify` **-** This controls the justification or location of printed text and can be `adafruit_thermal_printer.JUSTIFY_LEFT` **,** `adafruit_thermal_printer.JUSTIFY_CENTER` **,** or `adafruit_thermal_printer.JUSTIFY_RIGHT` **. ** The default is justify left.
For example to print thick underlined, medium text, with center justification:
```auto
printer.underline = adafruit_thermal_printer.UNDERLINE_THICK
printer.size = adafruit_thermal_printer.SIZE_MEDIUM
printer.justify = adafruit_thermal_printer.JUSTIFY_CENTER
printer.print('Medium center!')
# Reset back to normal printing:
printer.underline = None
printer.size = adafruit_thermal_printer.SIZE_SMALL
printer.justify = adafruit_thermal_printer.JUSTIFY_LEFT
# Feed lines to make visible:
printer.feed(2)
```
## Print Barcodes
Finally you can print a barcode with the `print_barcode` function. Each printer supports a different type and format of barcode so consult the product sheet in the downloads section for each type. However here's an example of printing a UPC A barcode with value '123456789012':
```auto
printer.print_barcode('123456789012', printer.UPC_A)
printer.feed(2)
```
The first parameter to `print_barcode` is a string that defines the barcode value (this varies depending on the type of barcode, a UPC A code is 13 digits). The second parameter is the type of the barcode, which again is dependent on the printer firmware. Typical values you might use include:
- `printer.UPC_A`
- `printer.UPC_E`
- `printer.EAN13`
- `printer.EAN8`
- `printer.CODE39`
- `printer.ITF`
- `printer.CODABAR`
- `printer.CODE93`
- `printer.CODE128`
## Check Paper
With some printers (not all, and it varies among firmware releases), if you've connected the RX pin of your board to the printer TX, ** ** you can query paper status with the `has_paper` function that returns `True` or `False` if there is paper present:
```auto
printer.has_paper()
```
That's all there is to using the thermal printer with CircuitPython!
A complete demo of the usage is in the [thermal\_printer\_simpletest.py demo in the library](https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer/blob/master/examples/thermal_printer_simpletest.py).
Warning:
On the Raspberry Pi, comment out the `uart = busio(...)` line, and uncomment the `import serial` and `uart = serial.Serial(...)` lines, changing `/dev/ttyUSB0` to the appropriate serial port.
Unless you used a voltage divider to hook up the printer TX line, make sure you comment out the paper check code:
```auto
# Check if the printer has paper. This only works if the RX line is connected
# on your board (but BE CAREFUL as mentioned above this RX line is 5V!)
#if printer.has_paper():
# print('Printer has paper!')
#else:
# print('Printer might be out of paper, or RX is disconnected!')
```
Now you can run the program with the following command:
```auto
python3 thermal_printer_simpletest.py
```
https://github.com/adafruit/Adafruit_CircuitPython_Thermal_Printer/blob/main/examples/thermal_printer_simpletest.py
# Mini Thermal Receipt Printers
## Python Docs
# Mini Thermal Receipt Printers
## Downloads
- [Adafruit\_Thermal library for Arduino](https://github.com/adafruit/Adafruit-Thermal-Printer-Library "Link: https://github.com/adafruit/Adafruit-Thermal-Printer-Library").
- [LCD Assistant](http://en.radzio.dxp.pl/bitmap_converter/) — optional bitmap conversion utility for Windows.
- [Processing](http://processing.org/download/) language — needed for bitmap conversion for Mac or Linux (and optionally Windows). DOWNLOAD VERSION 1.5.1, not the 2.0 beta.
- [Thermal Printer User Manual](http://www.adafruit.com/datasheets/CSN-A2%20User%20Manual.pdf).
- [An older version of the Thermal Printer User Manual](http://www.adafruit.com/datasheets/A2-user%20manual.pdf).
- [Thermal Printer Product Sheet](http://www.adafruit.com/datasheets/cashino%20thermal%20printer%20a2.pdf).
## Firmware Changer
If you'd like to risk it, you can revert/change the firmware using this tool that is from the manufacturer. We haven't tried it. It's completely utterly unsupported and you may break your printer. We won't replace it if it stops working due to a firmware change!
[update_firmware.zip](https://cdn-learn.adafruit.com/assets/assets/000/033/332/original/update_firmware.zip?1467047457)
# Mini Thermal Receipt Printers
## Troubleshooting!
###
First thing to try is the power up test. You do not need an Arduino for this.
**Make sure the paper is in the bay correctly, it should feed under and up so that the paper comes through the slot without bending.**
For _mini_ and _tiny_ printers, hold down the button on the top, then plug in the printer to power. It should print out a test page. On _nano_ printers and _guts,_ connect power first, then tap the button.
The printer’s LED will not be on solid, it will blink once in a while, that's normal.
###
Make sure you have a good power supply that can deliver the required current. If you are trying to operate at 5V, your power supply must be able to maintain a constant 5V even when the current demand spikes during printing. If your printer is making an attempt to print, but then struggling, then it is likely your power supply is dipping below 5V.
If you have one available, try a higher voltage power source, but no more than 9 Volts.
###
Make sure the paper is in the bay correctly, it should feed under and up so that the paper comes through the slot without bending.
Make sure the paper roll is not 'stuck' feeling in the bay, it should rotate easily!.
###
Some changes have been made to support a broader range of Arduino-like boards. Older code will require updating. Fortunately it's just a few lines around the global declarations and the setup() function.
Old syntax:
`Adafruit_Thermal printer(RX_PIN, TX_PIN);`
New syntax: declare a SoftwareSerial object and pass its address to the Adafruit\_Thermal constructor, like so:
`SoftwareSerial mySerial(RX_PIN, TX_PIN);`
`Adafruit_Thermal printer(&mySerial);`
Then, in the setup() function:
`mySerial.begin(19200);`
`printer.begin();`
Some boards (e.g. Arduino Due) have _multiple_ hardware serial ports, and the extras might be named `Serial1`, `Serial2`, etc. These can be used by passing the address of the serial device like so:
`Adafruit_Thermal printer(&Serial1);`
###
The printer's features and behavior have changed over various firmware releases.
First, check the PRINTER\_FIRMWARE value in Adafruit\_Thermal.h, make sure it matches the value at the bottom of the printer test page (hold down the paper feed button when connecting power to print out a test page).
Some features just behave a little differently among releases…barcodes, line feeds, etc.…if you were previously using an older library or an older printer, you may need to tweak the code to produce the desired formatting with a current setup.
###
_How_ a USB-attached printer manifests can vary by OS, USB adapter, printer firmware version and what other devices are attached. In Linux (e.g. Raspberry Pi), you might find the printer device at `/dev/serial0`, `/dev/usb/lp0`, `/dev/ttyAMA0`, `/dev/tty.USBserial0` or other names, and the digit(s) at the end might be different.
It’s common to snoop around in the system’s `/dev` directory, comparing with the USB cable disconnected and then connected, to find the printer’s device name. The `lsusb` command also sometimes helps.
Earlier model Tiny (USB) printers might appear by one of two different device names. Switching between them is explained toward the bottom of the “Making Connections” page. Newer units always appear in the `/dev/usb` subdirectory.
# Mini Thermal Receipt Printers
## Hacking!
Look at those huge, razor-sharp image prints! You want some?
The following…
- Is an **undocumented** printer feature and is **NOT guaranteed** to work.
- May require **modifying** your printer — a **warranty-voiding** operation! Continue at your own risk.
You should _only_ attempt this if **_all_** of the following apply:
- Have first confirmed that the **printer works as expected** when operated through **conventional procedures**.
- Have a **genuine performance bottleneck** that cannot be adequately resolved by **adjusting the printer** timing and thermal settings first.
- Are comfortable **opening things** and **soldering**.
Danger:
These printers have a limited serial receive buffer. Push bits to the printer faster than it can physically heat dots and feed paper, and you experience an “overflow” — bitmap images become garbled, text and formatting commands may be skipped.
The thermal printer library tries to throttle data to the printer at just the right rate. Too fast and an overflow occurs. Too slow and it wastes your time; the printer isn’t operating at peak throughput. This is an imperfect process…though we use very conservative timing estimates, the actual speed through the printer is impossible to predict…sometimes overflows _still_ occur.
_Hardware handshaking_ is a means by which a printer or other device can report to the microcontroller that it’s ready to receive more data, virtually eliminating buffer overflows while operating at peak throughput…the paper feed stops only when it physically absolutely must. Optimal performance.
It appears that some varieties of these thermal printers support hardware handshaking (e.g. firmware v2.64, 2.68). This is barely mentioned in the datasheet, and in fact **there isn’t even a physical connection for this on the outside of the printer.** A little surgery is in order…
Primary:
# Parts and Tools Needed
- Small Phillips head screwdriver
- Pliers
- Soldering iron and related paraphernalia
- A bit of wire…but ideally a female jumper wire
# Procedure
Unplug all cables, turn the printer over and remove the two small Phillips screws.
Take the back plate off, then remove the two (or sometimes four) Phillips screws holding the circuit board in place.
These screws are a little smaller than the back-holding ones…don’t get them mixed up!
Carefully, so as not to unseat or unplug the connectors, turn the circuit board over and look for the unpopulated via labeled “DTR.”
There are some other interesting solder points in here, if you’re so inclined. “HV” is the raw 5–9 Volts from the power supply. On the right is a 3.3V pin, though I don’t know the available current. Conceivably one could bring these out to reduce overall cabling in a project…or even install a tiny microcontroller right inside!
Cut an end off a female jumper wire and strip & tin the end.
This will be hanging out of the printer…so a _female_ jumper prevents accidental contact with things if you’re not using the connection. If you only have regular wire, that’s fine, just be careful not to leave a bare end dangling.
Solder the wire to the DTR pad. Top, bottom, doesn’t matter…it’s right up against the serial connection plug, so use whatever path works best for you, there’s ample room for routing the wire around either way.
Language pedants may note that this isn’t technically a DTR pin, but rather CTS. It’s long-standing thing among printer manufacturers…apparently the misnomer was made decades ago but has stuck for consistency.
On the back plate, there’s a small metal “finger” between the serial and power sockets. Using pliers, this can be bent back to provide an exit route for the DTR wire.
Screw the controller board back in place (check that neither of the cables has come unseated), routing the DTR wire around between the two sockets, then screw the back on.
Finished with the hardware!
You can then reconnect the power and serial sockets, and wire those up as before.
Use a jumper wire to connect DTR to any available Arduino pin. In our examples, we’ll use digital pin 4.
The printer electronics operate at 3.3V (but are “5V safe”), so no level shifting is needed with 3.3V boards (Arduino Due, etc.)…this can safely be connected directly.
# Code Changes
Just one line…the Adafruit\_Thermal constructor…needs changing. It can accept an optional parameter, a pin number to use for DTR:
```auto
Adafruit_Thermal printer(&mySerial, 4);
```
This works just as well with a hardware serial port (e.g. Arduino Mega or Due):
```auto
Adafruit_Thermal printer(&Serial1, 4);
```
No other changes are necessary. Try this with one of the example sketches…you’ll find the printer is suddenly _lots_ faster! That’s because the software throttle is no longer used…the printer continually reports its actual “ready” state to the microcontroller.
# Printing Huge Images
The printBitmap() function can output images from an open stream or stored in PROGMEM (flash memory)…as explained on the “Printing Bitmaps” page.
Although the Arduino Mega has a whopping 256K flash space, a limitation of the AVR microcontroller is that a single array can’t exceed 32K…that’s about a 384x680 pixel bitmap image. If you try to embed a larger image in your code, the compiler will report an error.
One workaround might be to break really long images into multiple smaller images, and print these out consecutively without a feed() in between.
Another is to use a non-AVR Arduino-compatible board, such as the 32-bit Arduino Due. This has no problem with massive arrays. The Chrysler Building image above is 384x1132 pixels!
# Other Things to Know
This type of printer fares best with light line art and sometimes dithered photographic images as long as the overall dot density is fairly low, like under 50%. Large solid-filled areas exhibit strange streaky artifacts…this isn’t a bug of the library or printer firmware, but just a side-effect of how receipt printers operate, that they can only heat so many dots at a time and have to pull shenanigans to go beyond that, else they jam.
Here are a couple examples from fancy commercial receipt printers.
Notice in the first one that the “solid black” area isn’t _really_ solid black…examining it closely, you can see it’s densely dithered, but not 100% filled.
The second _does_ have solid fills, but limits the total area. On any given row, only so many pixels are set.
If you try to print a “dense” image and the paper jams (image gets squashed vertically), pass a lower density value to printer.begin(). Default value is 120. So for example:
```auto
printer.begin(80);
```
DTR support is not a panacaea. **Glitches occasionally do still happen** …sometimes overflows, sometimes “framing errors” with serial data. But overall it seems fairly reliable and _buttery smooth!_
## Primary Products
### Mini Thermal Receipt Printer
[Mini Thermal Receipt Printer](https://www.adafruit.com/product/597)
Add a mini printer to any microcontroller project with this very cute thermal printer. Thermal printers are also known as receipt printers, they're what you get when you go to the ATM or grocery store. Now you can embed a little printer of your own into an enclosure. This printer is ideal...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/597)
[Related Guides to the Product](https://learn.adafruit.com/products/597/guides)
### Tiny Thermal Receipt Printer - TTL Serial / USB
[Tiny Thermal Receipt Printer - TTL Serial / USB](https://www.adafruit.com/product/2751)
Add a _really small_ printer to any microcontroller project with this very cute thermal printer. Thermal printers are also known as receipt printers, they're what you get when you go to the ATM or grocery store. Now you can embed a little printer of your own into an enclosure. This...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2751)
[Related Guides to the Product](https://learn.adafruit.com/products/2751/guides)
### Nano Thermal Receipt Printer - TTL Serial
[Nano Thermal Receipt Printer - TTL Serial](https://www.adafruit.com/product/2752)
Add a _really really small_ printer to any microcontroller project with this very cute thermal printer. Thermal printers are also known as receipt printers, they're what you get when you go to the ATM or grocery store. Now you can embed a little printer of your own into an...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2752)
[Related Guides to the Product](https://learn.adafruit.com/products/2752/guides)
### Thermal Receipt Printer Guts
[Thermal Receipt Printer Guts](https://www.adafruit.com/product/2753)
Add printing capability to any microcontroller project with **just the innards of a thermal printer.** Thermal printers are also known as receipt printers, they're what you get when you go to the ATM or grocery store. Now you can embed a little printer of your own into a...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2753)
[Related Guides to the Product](https://learn.adafruit.com/products/2753/guides)
## Featured Products
### Mini Thermal Receipt Printer Starter Pack
[Mini Thermal Receipt Printer Starter Pack](https://www.adafruit.com/product/600)
Hit the ground running (and printing!) with this starter pack that includes a thermal printer and all the extras and save a few dollars while you're at it.
Includes:
- [A mini thermal receipt printer](http://www.adafruit.com/products/597) - with cables and...
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/600)
[Related Guides to the Product](https://learn.adafruit.com/products/600/guides)
### Female DC Power adapter - 2.1mm jack to screw terminal block
[Female DC Power adapter - 2.1mm jack to screw terminal block](https://www.adafruit.com/product/368)
If you need to connect a DC power wall wart to a board that doesn't have a DC jack - this adapter will come in very handy! There is a 2.1mm DC jack on one end, and a screw terminal block on the other. The terminals are labeled with positive/negative assuming a positive-tip configuration...
In Stock
[Buy Now](https://www.adafruit.com/product/368)
[Related Guides to the Product](https://learn.adafruit.com/products/368/guides)
### 5V 2A (2000mA) switching power supply - UL Listed
[5V 2A (2000mA) switching power supply - UL Listed](https://www.adafruit.com/product/276)
This is an FCC/CE certified and UL listed power supply. Need a lot of 5V power? This switching supply gives a clean regulated 5V output at up to 2000mA. 110 or 240 input, so it works in any country. The plugs are "US 2-prong" style so you may need a plug adapter, but you can pick one...
In Stock
[Buy Now](https://www.adafruit.com/product/276)
[Related Guides to the Product](https://learn.adafruit.com/products/276/guides)
### Thermal paper roll - 50' long, 2.25" wide
[Thermal paper roll - 50' long, 2.25" wide](https://www.adafruit.com/product/599)
A mini roll of thermal paper, this fits very nicely into our mini thermal printer. 2.25" wide (about 57mm) and 50 feet long (15 meters). BPA-free.
[Perfect for use with our mini thermal printer!](http://www.adafruit.com/products/597)
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/599)
[Related Guides to the Product](https://learn.adafruit.com/products/599/guides)
### Thermal Paper Roll - 33' long, 2.25"
[Thermal Paper Roll - 33' long, 2.25"](https://www.adafruit.com/product/2754)
A little roll of thermal paper! This fits very nicely into our [Tiny Thermal Receipt Printer](https://www.adafruit.com/products/2751). It's ~2.25" wide (about 57mm) and 33 feet long or about 10 meters.
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2754)
[Related Guides to the Product](https://learn.adafruit.com/products/2754/guides)
### Thermal Paper Roll - 16' long, 2.25"
[Thermal Paper Roll - 16' long, 2.25"](https://www.adafruit.com/product/2755)
A little roll of thermal paper! This fits very nicely into our [Nano Thermal Receipt Printer](https://www.adafruit.com/products/2752). It's ~2.25" wide (about 57mm) and 16 feet long or about 5 meters.
No Longer Stocked
[Buy Now](https://www.adafruit.com/product/2755)
[Related Guides to the Product](https://learn.adafruit.com/products/2755/guides)
### Adafruit METRO 328 Fully Assembled - Arduino IDE compatible
[Adafruit METRO 328 Fully Assembled - Arduino IDE compatible](https://www.adafruit.com/product/50)
We sure love the ATmega328 here at Adafruit, and we use them _a lot_ for our own projects. The processor has plenty of GPIO, Analog inputs, hardware UART SPI and I2C, timers and PWM galore - just enough for most simple projects. When we need to go small, we use a
Out of Stock
[Buy Now](https://www.adafruit.com/product/50)
[Related Guides to the Product](https://learn.adafruit.com/products/50/guides)
### Breadboarding wire bundle
[Breadboarding wire bundle](https://www.adafruit.com/product/153)
75 flexible stranded core wires with stiff ends molded on in red, orange, yellow, green, blue, brown, black and white. These are a major improvement over the "box of bent wires" that are sometimes sold with breadboards, and faster than stripping your own solid core wires. Makes...
In Stock
[Buy Now](https://www.adafruit.com/product/153)
[Related Guides to the Product](https://learn.adafruit.com/products/153/guides)
## Related Guides
- [Track Your Treats: Halloween Candy GPS Tracker](https://learn.adafruit.com/track-your-treats-halloween-candy-gps-tracker.md)
- [Bluefruit LE Connect for iOS and Android](https://learn.adafruit.com/bluefruit-le-connect.md)
- [Let’s Put LEDs in Things!](https://learn.adafruit.com/lets-put-leds-in-things.md)
- [Nokia 5110/3310 Monochrome LCD](https://learn.adafruit.com/nokia-5110-3310-monochrome-lcd.md)
- [2.8" TFT Touchscreen](https://learn.adafruit.com/2-8-tft-touchscreen.md)
- [OLED TRON Clock](https://learn.adafruit.com/oled-tron-clock.md)
- [Character LCDs](https://learn.adafruit.com/character-lcds.md)
- [Electronic Demon Costume](https://learn.adafruit.com/electronic-demon-costume.md)
- [Adafruit 16-channel PWM/Servo Shield](https://learn.adafruit.com/adafruit-16-channel-pwm-slash-servo-shield.md)
- [Arduino Lesson 2. LEDs](https://learn.adafruit.com/adafruit-arduino-lesson-2-leds.md)
- [2.2" TFT Display](https://learn.adafruit.com/2-2-tft-display.md)
- [Arduino GPS Clock](https://learn.adafruit.com/arduino-clock.md)
- [Adafruit Data Logger Shield](https://learn.adafruit.com/adafruit-data-logger-shield.md)
- [WiFi Candy Bowl Monitor](https://learn.adafruit.com/wifi-candy-bowl.md)
- [Making Adabot: Part 2](https://learn.adafruit.com/making-adabot-part-2.md)