How to display sensor data on a 128x32 COG LCD display?

By admin 2026-08-06

How to Display Sensor Data on a 128x32 COG LCD Display

To display sensor data on a 128x32 COG (Chip-On-Glass) LCD display, you need to interface it with a microcontroller like an Arduino, ESP32, or STM32, using SPI (Serial Peripheral Interface) or I2C (Inter-Integrated Circuit) communication. The display, such as the 128x32 cog lcd display, typically uses a driver IC like the SSD1306 or ST7565, which supports 128x32 pixel resolution. For example, if you're reading temperature from a DHT22 sensor, you can send the data (e.g., 23.5°C) to the display by writing to the display's buffer via SPI. The process involves initializing the display with specific command sequences (e.g., set display on, set contrast, set page address), then converting sensor readings into pixel data using a font library like Adafruit GFX. A real-world example: on an Arduino Uno, you'd connect the DHT22 data pin to digital pin 2, and the display's SPI pins (CS, DC, MOSI, SCK) to pins 10, 9, 11, and 13. The maximum refresh rate for this display is around 60 Hz, but for sensor data, updating every 1-2 seconds is typical to avoid flickering. Power consumption is low—about 0.1 mA in sleep mode and 5 mA during active display—making it ideal for battery-powered projects.

Hardware Setup and Pin Connections

For a reliable connection, you need to match the display's logic level with your microcontroller. Most 128x32 COG LCDs operate at 3.3V, but some are 5V tolerant. For instance, the SSD1306-based display uses 3.3V logic, so if you're using a 5V Arduino, you'll need level shifters on the SPI lines. Here's a typical pinout for an SPI-based 128x32 COG display: VCC (3.3V), GND, CS (chip select), DC (data/command), MOSI (master out slave in), SCK (serial clock), and RESET (optional, can be tied to VCC). For an I2C version, you'd use SDA and SCL lines. A common setup with an ESP32: connect CS to GPIO5, DC to GPIO17, MOSI to GPIO23, SCK to GPIO18, and VCC to 3.3V. The DHT22 sensor, which measures temperature and humidity, uses a single-wire protocol and requires a 4.7kΩ pull-up resistor on the data line. For a more precise sensor like the BME280 (I2C address 0x76), you connect SDA to GPIO21 and SCL to GPIO22. The display's contrast can be adjusted via software (e.g., sending 0x81 followed by a contrast value from 0 to 255), which is critical for readability in bright environments. The typical viewing angle is 6 o'clock, meaning the display is best viewed from below, but it can be rotated 180 degrees using a command.

Software Initialization and Data Flow

The software stack starts with initializing the display driver. For the SSD1306, you send a sequence of commands: 0xAE (display off), 0xD5 (set display clock divide ratio), 0x80 (default ratio), 0xA8 (set multiplex ratio), 0x1F (32 rows), 0xD3 (set display offset), 0x00 (no offset), 0x40 (set start line), 0x8D (charge pump), 0x14 (enable), 0x20 (set memory addressing mode), 0x00 (horizontal mode), 0xA1 (set segment re-map, column 127 to SEG0), 0xC8 (COM output scan direction, remapped mode), 0xDA (set COM pins), 0x02 (sequential, disable left/right remap), 0x81 (set contrast), 0xCF (default contrast), 0xD9 (set pre-charge period), 0xF1, 0xDB (set VCOMH deselect level), 0x40, 0xA4 (display on resume), 0xA6 (normal display, not inverted), 0xAF (display on). After this, you send data in pages (each page is 8 pixels tall, so 32 rows = 4 pages). For sensor data, you read the sensor value, convert it to a string (e.g., "Temp: 23.5C"), then use a font library to map each character to pixel data. For example, the Adafruit GFX library's drawChar() function writes a 5x7 font character by setting pixels in the buffer. The buffer size is 128 * 32 / 8 = 512 bytes. You update the buffer with new sensor readings every 1-2 seconds, then call display.display() to send the buffer over SPI. The SPI clock speed is typically 4-8 MHz, so a full buffer transfer takes about 512 * 8 / 4e6 = 1.024 ms, which is negligible.

Handling Multiple Sensor Data Types

When displaying multiple sensor readings, you need to manage screen real estate. The 128x32 resolution gives you 128 columns and 32 rows. With a 5x7 font, you can fit about 25 characters per line (128/5 ≈ 25.6, but with spacing, 20-22 characters is practical). For two lines of text, you have 16 rows per line (since each character is 7 pixels tall plus 1 pixel spacing). For example, you can display "Temp: 23.5C" on the first line and "Hum: 65.2%" on the second line. If you have more data, like from a BMP280 (pressure) and a CCS811 (CO2), you can cycle through pages or use a smaller font (e.g., 3x5). The font library must be compiled into the microcontroller's flash memory; for an Arduino Uno with 32KB flash, a 5x7 ASCII font set (95 characters) takes about 95 * 5 = 475 bytes. For a custom font, you can store it in PROGMEM to save RAM. The sensor data itself is read via analog or digital pins; for example, the DHT22 returns a 40-bit data packet (16 bits for humidity, 16 bits for temperature, 8 bits checksum) at a 0.5 Hz sampling rate. The BME280, on the other hand, can sample at up to 182 Hz in forced mode, but for display, you'd use oversampling to reduce noise (e.g., 2x oversampling for temperature, which gives a resolution of 0.01°C).

Power Management and Optimization

For battery-powered applications, the 128x32 COG display's low power consumption is a key advantage. The SSD1306 can be put into sleep mode (0xAE command) when not updating, drawing only 0.1 μA. In active mode, the display draws about 5-10 mA depending on the number of lit pixels. For a project using an ESP32 with deep sleep, you can wake every 60 seconds, read the sensor, update the display, then go back to sleep. The display's internal charge pump can be disabled in sleep mode to save power. For example, a typical setup with a 2000 mAh battery lasts about 2000 mAh / (5 mA + 0.1 mA) ≈ 400 hours if the display is always on, but with duty cycling (e.g., 1 second on, 59 seconds off), the average current is (5 mA * 1/60) + 0.1 mA ≈ 0.183 mA, extending battery life to over 10,000 hours. The display's contrast can also be reduced to lower power; setting contrast to 0x00 (minimum) reduces current by about 1 mA. For sensor data, you don't need high contrast, so a value of 0x40 (64) is often sufficient.

Real-World Example: Temperature and Humidity Monitor

Here's a concrete implementation using an Arduino Nano and a DHT22 sensor. The display is a 128x32 COG with SSD1306 driver over SPI. The wiring: DHT22 data pin to D2, display CS to D10, DC to D9, MOSI to D11, SCK to D13, VCC to 3.3V, GND to GND. The code uses the Adafruit_SSD1306 library and the DHT sensor library. In the setup, you initialize the display with display.begin(SSD1306_SWITCHCAPVCC, 0x3C) (for I2C) or display.begin(SSD1306_SWITCHCAPVCC, 0x3C, &SPI, CS, DC, MOSI, SCK) for SPI. Then in the loop, you read the DHT22: float temp = dht.readTemperature(); float hum = dht.readHumidity();. You clear the display buffer, set text size to 1, set cursor to (0,0), print "Temp: ", then print temp with one decimal place, and on the next line print "Hum: ". You call display.display() to update the screen. The DHT22 has a 2-second minimum sampling interval, so you add a delay of 2000 ms. The display's buffer is updated only when new data is available, preventing unnecessary SPI traffic. For accuracy, the DHT22 has a temperature accuracy of ±0.5°C and humidity accuracy of ±2% RH. If you want higher precision, use a BME280, which has ±0.5°C for temperature, ±3% for humidity, and ±1 hPa for pressure, with a resolution of 0.01°C, 0.008% RH, and 0.18 Pa.

Advanced Techniques: Graphics and Custom Fonts

Beyond text, you can display sensor data as graphs or bar charts. For example, you can plot temperature over time on the 128x32 display. Since the display is 128 pixels wide, you can store 128 data points (one per column) in a circular buffer. Each data point is scaled to fit in 32 pixels vertically. For instance, if temperature ranges from 0 to 50°C, you map 0°C to row 31 and 50°C to row 0. You draw a line from the previous point to the current point using the drawLine() function. The buffer is updated every 10 seconds, so you get a 21-minute history (128 * 10 / 60 = 21.3 minutes). You can also add a numeric readout at the top or bottom. For custom fonts, you can create a 8x16 font for larger characters, but that reduces the number of characters per line to 16 (128/8). The font data is stored as a byte array in PROGMEM. For example, a 8x16 font for the letter 'A' might be: {0x00, 0x18, 0x24, 0x42, 0x42, 0x7E, 0x42, 0x42, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}. You'd write a function to draw this font by reading the bits and setting pixels. The display's SPI communication must be fast enough to handle the graphics; with an 8 MHz SPI clock, a full buffer update for a graph takes about 1 ms, so you can update at 60 Hz without visible flicker.

Common Pitfalls and Troubleshooting

One common issue is the display not initializing due to incorrect SPI pin assignments. For example, if you use the Arduino's default SPI pins but the display expects different ones, you'll get no output. Always check the datasheet for the exact pinout. Another issue is the display's contrast being too low or too high. If the display appears blank, try sending a contrast command with a value of 0xCF (207) for the SSD1306. For the DHT22, if you get NaN readings, it's often due to a missing pull-up resistor or a timing issue. The DHT22 requires a 1-10 ms low pulse followed by a 20-40 μs high pulse from the microcontroller, and the sensor responds with a 80 μs low and 80 μs high. If your code uses delay() instead of delayMicroseconds(), you might miss the timing. For the display, if you see vertical lines or artifacts, it's likely due to a loose connection or a noisy power supply. Use a 10 μF capacitor between VCC and GND near the display to filter noise. Also, the display's SPI bus should not share lines with other devices unless they have separate CS pins; otherwise, you'll get data corruption. For example, if you have an SD card on the same SPI bus, ensure the display's CS is pulled high when the SD card is active.

Performance Metrics and Data Integrity

The display's refresh rate is limited by the SPI speed and the microcontroller's processing power. With an Arduino Uno at 16 MHz, the SPI clock is typically 4 MHz (half of system clock). Transferring 512 bytes takes 512 * 8 / 4e6 = 1.024 ms, but the library overhead adds about 2-3 ms, so a full update takes about 4 ms. For sensor data, this is fine. However, if you're also reading the sensor and doing other tasks, the loop time might be 10-20 ms. The display's internal buffer is double-buffered, so you can write to the buffer while the display is refreshing, preventing tearing. The sensor data accuracy depends on the sensor's ADC resolution. For example, the DHT22 uses a 14-bit ADC for temperature and 12-bit for humidity, giving a temperature resolution of 0.1°C and humidity of 0.1% RH. The BME280 has a 20-bit ADC for pressure, 16-bit for temperature, and 16-bit for humidity, but the effective resolution is lower due to noise. To improve accuracy, you can average multiple readings. For instance, take 10 readings of the DHT22 over 2 seconds and average them; this reduces the noise by a factor of sqrt(10) ≈ 3.16. The display's pixel accuracy is 1:1, meaning each pixel represents a single data point, so there's no interpolation error.

Integration with IoT and Cloud Platforms

For IoT applications, you can display sensor data locally while also sending it to the cloud. For example, using an ESP32, you can read a BME280 sensor, display the data on the 128x32 COG display, and send it to MQTT or HTTP endpoints. The display updates every 5 seconds, while the cloud upload happens every 60 seconds to save battery. The ESP32's Wi-Fi module draws about 80 mA during transmission, so you'd want to minimize that. You can use deep sleep between updates, waking only to read the sensor and update the display. The display's SPI lines can be shared with other peripherals if you use a multiplexer, but for simplicity, use dedicated GPIOs. The data format on the display can include the sensor name, value, and unit, e.g., "Temp: 23.5C", "Hum: 65.2%", "Pres: 1013.2 hPa". You can also display the Wi-Fi signal strength (RSSI) as a bar graph. For example, if RSSI is -50 dBm, you show 4 bars; if -80 dBm, 2 bars. The display's contrast can be adjusted based on ambient light using a photoresistor, but that adds complexity. A simpler approach is to set a fixed contrast that works for most conditions.

Hardware Variants and Compatibility

There are several variants of 128x32 COG LCDs. Some use the ST7565 driver, which is similar to the SSD1306 but requires different initialization commands. For example, the ST7565 uses a 132x65 pixel matrix, but only 128x32 are visible. The SPI commands for ST7565 include 0xA0 (ADC select, normal), 0xC0 (common output mode, normal), and 0xA2 (bias set, 1/9). The display's voltage range is typically 2.7V to 3.6V, and the logic level is 1.8V to 5.5V. For compatibility with 5V microcontrollers, use a level shifter like the 74LVC245. The display's temperature range is -20°C to +70°C, which covers most indoor applications. For outdoor use, you might need a wider range, but the COG technology is sensitive to extreme temperatures. The display's viewing angle is 6 o'clock, meaning it's best viewed from below, but you can rotate it 180 degrees using a command (e.g., 0xC0 for ST7565). The display's response time is about 10-20 ms, so it's not suitable for fast-moving graphics, but for sensor data, it's fine. The display's lifespan is typically 50,000 hours at 25°C, which is about 5.7 years of continuous use.

Code Optimization and Memory Management

For microcontrollers with limited RAM, like the Arduino Uno (2KB), the display buffer (512 bytes) takes up 25% of RAM. To save memory, you can use a smaller buffer, like a 128x8 pixel page buffer, and update the display page by page. For example, you can store only the current page (128 bytes) and send it to the display when needed. This reduces RAM usage to 128 bytes, but requires more frequent SPI transfers. The font data