Build Instructions

Collapse

• 1

  Resize the Image

  The QR204 thermal printer has a maximum printable width of 384 pixels. Any image wider than this will either be cropped or distorted.

  Recommended image size:

  Width : 384 pixels
Height : Any value (280 pixels used in this project)

  Width  : 384 pixelsHeight : Any value (280 pixels used in this project)

  If your image is larger, resize it before importing it into Image2CPP.

• 2

  Open Image2CPP

  Open Image2CPP and load your image.

  Configure the settings exactly as shown below.

  Image Settings

  Background

  White

  Color Mode

  Monochrome

  Brightness

  128 (default works well)

  Output Setting

  Select

  Horizontal - 1 bit per pixel

  Disable

  Compression

  Output Format

  Arduino Code

  Do not enable any byte swapping or special encoding options.

  Finally, click Generate Code.

  Image2CPP will produce something similar t

  const unsigned char epd_bitmap[] = {0xFF,0xFF,0xFF,...};

  Copy the complete array.

  Arduino Boilerplate

  The following sketch acts as a reusable template.

  The only thing you'll need to replace in future projects is the Image2CPP array.

  Simply paste the generated bitmap inside:

  const uint8_t epd_bitmap[] = {    // Paste Image2CPP output here};

  Then update

  #define IMAGE_WIDTH#define IMAGE_HEIGHT

  Everything else remains unchanged.

  Understanding the Printer Commands

  The QR204 printer communicates using ESC/POS commands.

  The first command initializes the printer.

  PRINTER.write(0x1B);PRINTER.write('@');

  This clears the printer's internal state before sending new data.

  Next comes the raster bitmap command.

  PRINTER.write(0x1D);PRINTER.write('v');PRINTER.write('0');PRINTER.write(0);

  This tells the printer that the following bytes represent a bitmap image.

  The printer then needs to know the dimensions of the image.

  First, the width is transmitted in bytes, not pixels.

  uint16_t bytesPerLine = width / 8;

  Since every byte represents eight pixels, a 384-pixel image becomes

  384 / 8 = 48 bytes

  Those bytes are then transmitted as

  PRINTER.write(bytesPerLine & 0xFF);PRINTER.write(bytesPerLine >> 8);

  The image height is transmitted in a similar manner.

  PRINTER.write(height & 0xFF);PRINTER.write(height >> 8);

  Once the printer knows the dimensions, it simply waits for

  Width × Height

  worth of bitmap data.

  The Interesting Discovery

  Initially, everything appeared correct.

  The ESC/POS command was valid.

  The printer received the correct image dimensions.

  The bitmap array generated by Image2CPP was also correct.

  Yet the printer produced:

  • Scrambled graphics
  • Thick black bars
  • Distorted logos
  • Random symbols

  At first, it looked like a communication problem.

  However, after testing different baud rates, power supplies, image sizes, and ESC/POS commands, the real issue turned out to be much simpler.

  The QR204 printer expects every bitmap byte to be transmitted with its bit order reversed.

  For example,

  Normal

  10010000

  must become

  00001001

  before sending it to the printer.

  This tiny detail completely changes the output quality.

  Reversing the Bit Order

  The following function reverses all eight bits inside a byte

  uint8_t reverseBits(uint8_t b){    b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;    b = (b & 0xCC) >> 2 | (b & 0x33) << 2;    b = (b & 0xAA) >> 1 | (b & 0x55) << 1;    return b;}

  Before transmitting every byte, simply execute

  uint8_t b = reverseBits(bmp[i]);PRINTER.write(b);

  This single line solved the bitmap rendering problem entirely.

  Printing the Bitmap

  The complete bitmap printing routine calculates the image size, initializes the printer, sends the raster command, transmits the dimensions, and finally streams the bitmap data byte by byte.

  Since Image2CPP already generates a perfectly formatted bitmap array, the Arduino only needs to iterate through every byte and send it to the printer after reversing its bit order.

  The result is a sharp, correctly aligned bitmap printed directly onto the thermal paper.

  First Successful Print

  After implementing the bit-reversal function, the QR204 immediately produced a clean bitmap with correct proportions and alignment.

  This approach works reliably for

  • Company logos
  • School logos
  • QR codes
  • Icons
  • Small graphics
  • Certificates
  • Attendance slips
  • Custom receipt

  Because the code uses a reusable boilerplate, printing a different image is as simple as replacing the Image2CPP array with a new one.

  Troubleshooting Guide

  One of the most interesting aspects of this project was the amount of debugging required before achieving a successful print. Although printing plain text worked immediately, printing bitmap graphics involved several challenges. This section summarizes the most common issues encountered during development and explains how each one was resolved.

  If your printer doesn't produce the expected output, the following troubleshooting steps will help you identify the problem quickly.

  Problem 1 – Random Characters Instead of an Image

  Typical output looked like:

  <B  B<X(Hello

  Cause

  The printer was interpreting the bitmap bytes as regular text instead of raster graphics.

  Possible reasons include:

  • Incorrect ESC/POS command sequence
  • Wrong baud rate
  • Corrupted serial communication

  Solution

  Verify that the printer is configured for 9600 baud and ensure the bitmap is transmitted using the GS v 0 raster image command.

  Problem 2 – Only Text Prints

  Sometimes the printer would print:

  END

  without printing the image.

  Cause

  The raster command was being accepted, but no valid bitmap data followed.

  Solution

  Check:

  • Image width
  • Image height
  • Total number of transmitted bytes

  The total bitmap size should always be:

  (width / 8) × height

  For a 384 × 280 image:

  48 × 280 = 13,440 bytes

  If fewer bytes are transmitted, the printer simply skips the image.

  Problem 3 – A Single Black Dot

  One of the earliest tests printed only a single black dot followed by normal text.

  Cause

  The raster command itself was correct.

  However, only one byte of image data was reaching the printer.

  Solution

  Increase the bitmap width and verify that the complete image buffer is transmitted.

  This test confirmed that the printer supported raster graphic

  Problem 4 – Thick Black Horizontal Line

  Increasing the transmitted data produced a thick black horizontal line.

  Although this wasn't the desired image, it actually confirmed something very important.

  It proved that:

  • Communication was working correctly.
  • ESC/POS raster commands were supported.
  • The printer was interpreting bitmap data successfully.

  The only remaining issue was the bitmap layout.

  Problem 5 – Completely Distorted Image

  After transmitting the full bitmap, the printer produced a heavily distorted image.

  At this stage it appeared as though the bitmap itself was incorrect.

  Several possibilities were investigated:

  • Wrong raster command
  • Incorrect width calculation
  • Wrong image orientation
  • Data alignment issues
  • ESC * graphics mode
  • GS v 0 raster mode
  • Image2CPP settings
  • Printer firmware differences

  None of these solved the issue.

  The Actual Solution

  After carefully analyzing the output, it became clear that the printer expected every byte with its bit order reversed.

  Instead of transmitting

  10010000

  the printer expected

  00001001

  The following function solved the problem completely.

  uint8_t reverseBits(uint8_t b){    b = (b & 0xF0) >> 4 | (b & 0x0F) << 4;    b = (b & 0xCC) >> 2 | (b & 0x33) << 2;    b = (b & 0xAA) >> 1 | (b & 0x55) << 1;    return b;}

  Every transmitted byte is processed using:

  PRINTER.write(reverseBits(bmp[i]));

  After implementing this single change, the bitmap printed perfectly.

  Problem 6 – Black and White Colors Swapped

  Sometimes the printed image appeared as a photographic negative.

  White became black and black became white.

  Cause

  The bitmap bytes were inverted before transmission.

  ~b

  Solution

  Do not invert the data.

  Simply transmit

  reverseBits(b);

  This preserves the correct pixel polarity.

  Problem 7 – Printer Resets During Image Printing

  Printing text worked correctly.

  However, larger images caused incomplete prints or printer resets.

  Cause

  The printer was initially powered directly from the Arduino's 5V pin.

  While text printing consumes relatively little current, printing a bitmap activates hundreds of heating elements simultaneously, causing the current demand to increase significantly.

  Solution

  Use a dedicated:

  • 5V
  • 2A (or higher)

  regulated power supply.

  Also ensure that the Arduino ground and printer ground are connected together.

  After switching to an external supply, printing became stable and reliable.

  Testing Strategy

  Rather than immediately sending a large bitmap, smaller tests were used to verify each stage of the communication.

  The debugging sequence looked like this:

  • Print plain text.
  • Initialize the printer.
  • Print a single black pixel.
  • Print an 8 × 8 square.
  • Print a horizontal black strip.
  • Print a small bitmap.
  • Print the complete 384 × 280 image.

  This systematic approach made it much easier to identify exactly where the problem occurred.

  Performance Results

  After implementing the final solution, the printer successfully produced high-quality monochrome graphics.

  Test Platform

  Component

  Specification

  Microcontroller

  Arduino UNO R4 WiFi

  Printer

  QR204 58 mm TTL Thermal Printer

  Baud Rate

  9600

  Image Width

  384 pixels

  Image Height

  280 pixels

  Successful Tests

  Successful Tests

  • Company logos
  • School logos
  • QR Codes
  • Icons
  • Small graphics
  • Certificates
  • Attendance slips
  • Custom receipts

  Because the code uses a reusable boilerplate, printing a different image is as simple as replacing the Image2CPP array with a new one.

  • School logos
  • Custom graphics
  • Icons
  • QR codes
  • Receipt headers
  • Attendance system branding

  Each image printed cleanly with correct proportions and sharp edges.

  Real-World Applications

  With bitmap printing working correctly, the same boilerplate can now be integrated into numerous embedded systems.

  Some examples include:

  • Smart School Attendance System
  • RFID Access Control
  • Library Management Systems
  • Hospital Registration Kiosks
  • Restaurant Billing Systems
  • POS Machines
  • Smart Inventory Management
  • Visitor Management Systems
  • IoT Receipt Printing
  • Event Ticketing
  • Portable Label Printers
  • Industrial Data Logging

  Instead of printing plain text, these applications can now include company logos, QR codes, signatures, custom icons, and branded graphics, giving the final product a much more professional appearance.

View all instructions