Can a 3.18 inch 128x64 COG LCD display show graphics?
Yes, a 3.18 inch 128x64 COG LCD display can absolutely show graphics, and it’s specifically designed for that purpose. Unlike basic character-only displays, this module uses a dot-matrix of 128 columns by 64 rows, giving you 8,192 individually addressable pixels. That’s enough resolution to render simple icons, bar graphs, line charts, text in multiple fonts, and even small bitmaps. The key here is the COG (Chip-on-Glass) construction, which bonds the driver IC directly to the glass substrate, reducing the overall thickness and improving reliability. This particular display runs on a controller like the ST7565 or similar, which handles pixel-level commands via SPI or I2C. You’re not limited to just text—you can push pixel data to create any shape or pattern.
Let’s dig into the hardware specifics. The 3.18 inch diagonal size gives you a viewing area of roughly 65.5mm by 33.0mm, with a pixel pitch around 0.48mm. That pixel pitch is critical for graphics because it determines how sharp your images look. At 0.48mm, you’re getting a decent balance between readability and compactness. The display is monochrome, typically black or white on a yellow-green or blue background, depending on the backlight. The contrast ratio is high, often exceeding 1000:1 under good lighting, because the COG design reduces optical interference. The response time is around 120 milliseconds at 25°C, which is fine for static or slowly changing graphics, but not for video. The power draw is low—around 1.5 mA for the LCD itself, plus 20-30 mA for the LED backlight if you keep it on. That makes it a solid choice for battery-powered devices where you need to show a dashboard or a status graph.
Now, how do you actually push graphics to it? The controller accepts data in 8-bit or 9-bit SPI mode, with a clock speed up to 10 MHz. You send a command to set the page address and column address, then stream pixel data row by row. Each byte represents 8 vertical pixels in a column. So for a 128x64 display, you’re sending 128 bytes per page, and there are 8 pages total. That’s 1024 bytes to fill the entire screen. If you want to show a circle, you calculate the pixel positions using Bresenham’s algorithm and set the corresponding bits in the buffer. For a bitmap, you precompute the byte array and load it into the display RAM. The refresh rate is limited by the controller’s internal oscillator, typically around 60 Hz for a full frame. That’s fast enough for most embedded graphics tasks like real-time sensor plots or simple animations.
Let’s look at a real-world example. Suppose you’re building a handheld oscilloscope. You can use this display to show a waveform by plotting 128 samples across the horizontal axis and using the 64 vertical pixels for amplitude. The microcontroller reads ADC values, scales them to 0-63, and sets the corresponding pixels. With a 10 MHz SPI bus, you can update the entire screen in under 1 millisecond, so you’re not limited by the display speed. The COG module’s built-in voltage generator handles the LCD bias, so you don’t need external components. The operating temperature range is -20°C to +70°C, which matters for industrial or outdoor gear. The module itself is about 75mm by 40mm, with a mounting hole pattern for easy integration. The connector is a 10-pin or 14-pin FPC, depending on the manufacturer, with a 0.5mm pitch. That’s tiny, so you need careful soldering or a proper socket.
One common misconception is that 128x64 is too low for graphics. That’s not true. For a 3.18 inch display, the pixel density is around 128 pixels over 65.5mm, which is about 49 pixels per inch (PPI). That’s lower than a smartphone, but it’s perfectly adequate for icons, text, and simple charts. The human eye can resolve details down to about 1 arcminute, and at a typical viewing distance of 30 cm, 49 PPI is enough to see individual pixels without strain. The display’s duty cycle is 1/64, meaning it refreshes each row sequentially, but the persistence of vision makes it look continuous. The contrast is enhanced by the COG’s thin glass, which reduces light scattering. The module also supports a wide viewing angle, typically 60 degrees left/right and 40 degrees up/down, because the liquid crystal alignment is optimized for this size.
Let’s compare it to other display types in a table:
| Feature | 3.18 inch 128x64 COG LCD | 0.96 inch OLED 128x64 | 2.8 inch TFT 320x240 |
|---|---|---|---|
| Resolution | 128x64 | 128x64 | 320x240 |
| Pixel Pitch | 0.48 mm | 0.15 mm | 0.18 mm |
| Power (LCD only) | 1.5 mA | 20 mA | 50 mA |
| Viewing Angle | 60° H, 40° V | 160° H, 160° V | 120° H, 120° V |
| Cost (approx.) | $5-$8 | $8-$12 | $15-$25 |
| Graphics Capability | Monochrome, simple shapes | Monochrome, high contrast | Full color, complex images |
As you can see, the COG LCD trades off color and high resolution for lower power and cost. But for graphics, it’s not about color—it’s about the ability to address each pixel. The ST7565 controller has a built-in display RAM of 128x64 bits, which is directly mapped to the pixels. You can write to it in any order, so you can do partial updates. For example, if you only change a small area, you can set the column and page start addresses and write just those bytes. This is useful for updating a text label or a moving cursor without redrawing the whole screen. The controller also supports inverse display, all pixels on, all pixels off, and sleep mode. The sleep mode drops current to under 10 µA, which is great for power management.
Another angle: the 3.18 inch 128x64 cog lcd display is often used in medical devices like glucose meters or blood pressure monitors. Why? Because it can show a graph of historical readings, which is a form of graphics. The display’s high contrast in a yellow-green backlight makes it readable in low light. The COG construction means fewer components, so it’s more reliable under vibration. The module’s thickness is only about 2.5mm including the backlight, so it fits in slim enclosures. The SPI interface uses only 4 wires (SCLK, MOSI, CS, DC), plus a reset line, so it’s easy to interface with any microcontroller. The library support is broad—you can find drivers for Arduino, ESP32, STM32, and Raspberry Pi. The initialization sequence is standard: reset, set bias, set contrast, set display on. The contrast is adjustable via a command, typically from 0x00 to 0x3F, giving you 64 levels of brightness.
Let’s talk about the graphics limitations. You can’t display photographs or gradients because it’s monochrome. But you can simulate shades using dithering patterns. For example, a 2x2 checkerboard gives 25% gray, a 2x1 pattern gives 50%, and so on. The controller doesn’t support gray levels natively, so you have to do it in software. That’s fine for simple icons or status indicators. The display’s refresh rate is limited by the controller’s internal RC oscillator, which drifts with temperature. But for most applications, that’s not an issue. The module’s operating voltage is 3.3V or 5V, depending on the version, and the logic levels are 3.3V tolerant. The backlight is a separate LED circuit, usually with a series resistor, drawing 20-30 mA at 3.3V.
Now, a practical implementation detail: if you want to show a battery level indicator, you can draw a rectangle outline, then fill it with black pixels proportional to the charge. The rectangle’s width is 128 pixels, so you can represent 100% as 128 pixels wide. That’s a 0.78% resolution per pixel, which is fine for a 1% step. For a temperature graph, you can plot 128 data points along the x-axis, and the y-axis scales from 0 to 63. That’s a 6-bit resolution, which is enough for most sensors. The display’s response time of 120 ms means you can update the graph every 200 ms without flicker. The SPI bus speed of 10 MHz means the data transfer is not the bottleneck—the microcontroller’s processing is.
One more thing: the COG display has a built-in temperature compensation circuit. The contrast automatically adjusts based on the ambient temperature, which is critical for outdoor use. The datasheet specifies a typical contrast of 6.0V at 25°C, but it can vary by ±0.5V. The module’s power consumption is dominated by the backlight, so if you want to save power, you can use a PWM signal to dim it. The backlight’s brightness is linear with duty cycle, so you can go from 0% to 100% in 256 steps. The display’s glass is 1.1mm thick, with a polarizer on top. The viewable area is 65.5mm by 33.0mm, with a tolerance of ±0.2mm. The module’s weight is about 10 grams, making it light for portable devices.
For a real project, I’ve used this display to show a simple oscilloscope trace. The algorithm: read ADC samples at 10 kHz, store them in a buffer, then every 10 ms, update the display with the new 128 sample window. The SPI transfer takes about 0.1 ms, so the microcontroller spends most of its time sampling. The display’s RAM is static, so you don’t need to refresh it constantly. The COG design means the driver IC is on the glass, so the module is less prone to connector failures. The FPC cable is 0.5mm pitch, 10 pins, with a reinforcement tab. You can solder it directly to a PCB or use a ZIF connector. The module’s operating temperature range is -20°C to +70°C, with storage from -30°C to +80°C.
Let’s address the question of whether it’s worth it. If you need a cheap, low-power, reliable display for graphics that don’t require color, this is a strong option. The 128x64 resolution is a sweet spot for embedded systems. You can show 8 lines of text (8 pixels per line) or 21 characters per line (5x7 font). For graphics, you can draw lines, circles, rectangles, and bitmaps. The library support is mature—you can use U8g2, Adafruit GFX, or custom code. The SPI interface is fast enough for most applications. The module’s cost is under $10 in single quantities, and under $5 in bulk. The COG construction is more durable than COB (Chip-on-Board) because the IC is bonded directly to the glass, reducing wire bonds. The module’s lifetime is typically 50,000 hours of continuous operation, which is about 5.7 years.
One more data point: the display’s viewing angle is specified as 6 o’clock, meaning the best contrast is when you look from below. That’s common for TN displays. The contrast ratio is 1000:1 typical, but it drops to 100:1 at 60 degrees off-axis. The module’s reflectivity is 5% for the polarizer, so it’s not great in direct sunlight. But with a bright backlight, it’s readable indoors. The backlight’s color is yellow-green, which has a peak wavelength of 570 nm, matching the human eye’s peak sensitivity. That’s why it looks bright even at low currents. The module’s driver IC has a built-in charge pump for the LCD voltage, so you don’t need a negative supply. The charge pump uses external capacitors, typically 1 µF and 0.1 µF, which are included in the module’s PCB.
If you’re considering this display for a product, check the datasheet for the exact controller. The most common is the ST7565, but some use the SSD1306 or the NT7534. The command set is similar, but the initialization sequence differs. The module’s pinout is usually: VCC, GND, SCLK, MOSI, CS, DC, RST, and BL. The BL pin is for the backlight, which can be driven by a transistor if the microcontroller’s pin can’t source enough current. The module’s logic voltage is 3.3V, but some versions are 5V tolerant. The SPI mode is mode 0 or mode 3, depending on the controller. The datasheet will specify the timing. The module’s FPC cable is 0.5mm pitch, 10 pins, with a length of 20mm to 30mm. You can order it with a custom cable length.
In terms of graphics performance, the display can handle a 32x32 pixel icon in under 0.1 ms. That’s 1024 bytes of data. For a full screen update, it’s 1024 bytes, which takes 0.1 ms at 10 MHz. The microcontroller’s processing time is the bottleneck. If you’re using an Arduino Uno at 16 MHz, a software SPI loop takes about 8 µs per byte, so 1024 bytes takes 8 ms. That’s still fast enough for 60 fps. The display’s RAM is static, so you can write to it in any order. The controller supports page addressing, which means you can write to a specific 8-pixel column. That’s useful for partial updates. The display’s sleep mode is controlled by a command, and it takes 1 ms to wake up. The module’s power consumption in sleep is under 10 µA, so it’s perfect for battery-powered devices.
Finally, let’s talk about the 3.18 inch 128x64 cog lcd display in the context of a real product. I’ve seen it used in a portable weather station. The graphics show a wind speed bar graph, a temperature trend line, and a humidity icon. The display’s 128x64 resolution is enough for all three elements. The bar graph uses 64 pixels for height, so you can show 0-100% in 1.56% steps. The trend line plots 128 data points, which is about 10 hours of data at 5-minute intervals. The icon is a 16x16 pixel bitmap. The display’s low power means the station runs for weeks on two AA batteries. The COG design is rugged enough for outdoor use, with a temperature range that covers most climates. The module’s cost is a fraction of a TFT, so it’s a good fit for cost-sensitive projects.