If you’re looking at a 0.95 inch 96x64 OLED, the driver chip you’re dealing with is almost always the SSD1331. This is a single-chip CMOS OLED driver from Solomon Systech, specifically designed for small, high-resolution color displays. The SSD1331 handles a 96x64 pixel matrix with 16-bit color depth (65,536 colors), supports a full 262K color palette via internal RAM, and operates over a 4-wire SPI interface. It’s the go-to controller for these tiny panels because it integrates the row driver, column driver, and a 96x64x16-bit SRAM buffer directly on-chip, which keeps the footprint small and the pin count low. You’ll find this chip in nearly every 0.95-inch 96x64 OLED module on the market, including the 0.95 inch 96x64 color oled display from DisplayModule. The SSD1331 datasheet lists a maximum clock frequency of 20 MHz for SPI, which translates to a frame rate of around 60 fps for full-screen updates, though real-world performance depends on your microcontroller’s SPI speed and the amount of data you push per frame.
Let’s get into the hardware specifics. The SSD1331 is a 0.18-μm CMOS process chip, packaged in a 48-pin QFN (Quad Flat No-leads) that measures 7x7 mm. It draws about 10-20 mA during active operation at 3.3V, depending on the OLED brightness and pixel content. The chip has a built-in DC-DC converter that generates the high voltage needed for the OLED panel—typically 7V to 15V for the organic layers—so you don’t need an external boost converter. This converter is a charge pump design, using external capacitors (usually 1 μF and 10 μF) to step up the input voltage. The SSD1331 also includes a gamma correction block, which adjusts the gray-scale voltage levels for each color channel (R, G, B) to compensate for the OLED’s non-linear brightness response. The default gamma curve is set for a 2.2 gamma, but you can reprogram it via SPI commands if you want to tweak the color balance. The chip’s internal oscillator runs at 1.5 MHz typical, but you can also feed an external clock if you need precise timing for synchronized displays.
The SPI interface on the SSD1331 is a 4-wire setup: CS (chip select), DC (data/command), SCLK (serial clock), and SDIN (serial data input). There’s no MISO pin because the chip is write-only for data—you can’t read back the pixel buffer. The command set is extensive, with over 40 registers controlling everything from display mode (normal, inverse, all-on, all-off) to segment mapping, COM (common) output scan direction, and pre-charge timing. For example, the “Set Re-map” command (0xA0) lets you flip the X and Y axes, which is handy if you mount the display upside down. The “Set Display Start Line” command (0xA1) shifts the vertical scroll offset. The “Set Contrast” command (0x81) adjusts the current for each color channel separately, with a range of 0x00 to 0xFF. The default contrast values are typically 0x7F for all colors, but you can crank them up to 0xFF for maximum brightness, though that increases power draw to about 25 mA.
Now, let’s talk about the pixel structure. The SSD1331 uses a 16-bit color format: 5 bits for red, 6 bits for green, and 5 bits for blue (RGB565). This gives 32 levels of red, 64 levels of green, and 32 levels of blue, totaling 65,536 colors. The internal RAM is organized as 96 columns x 64 rows x 16 bits, which is exactly 12,288 bytes (96 * 64 * 2). When you send a pixel over SPI, you need to send two bytes per pixel: the first byte contains the high 8 bits (R[4:0] and G[5:3]), and the second byte contains the low 8 bits (G[2:0] and B[4:0]). For a full-screen update, you’re sending 96 * 64 * 2 = 12,288 bytes. At 20 MHz SPI clock, that’s about 0.6 ms per byte transmission (8 bits / 20 MHz = 0.4 μs per bit, plus overhead), so a full frame takes roughly 5 ms, not counting command overhead. In practice, with a typical Arduino running at 16 MHz, you’ll see about 10-15 fps for full-screen updates, but partial updates (like drawing a small icon) can be much faster.
One common misconception is that the SSD1331 is the same as the SSD1306 or SH1106, which are used in monochrome OLEDs. They’re not. The SSD1306 is a 128x64 monochrome driver with a 1-bit per pixel buffer, while the SSD1331 is a color driver with 16-bit per pixel. The pinout is different too: the SSD1306 often uses I2C or SPI, but the SSD1331 is strictly SPI. The SH1106 is a 132x64 monochrome driver that’s often used in 1.3-inch OLEDs, but it doesn’t support color at all. So if you’re buying a 0.95-inch 96x64 color OLED, you’re getting the SSD1331. There’s no alternative driver chip for this specific size and resolution in the consumer market. Some older modules used the SSD1351 (which is a 128x128 color driver), but that’s a different chip with a different command set and higher resolution. The SSD1331 is the only one that fits the 96x64 matrix.
Let’s look at the physical layer of the OLED panel itself. The 0.95-inch 96x64 OLED uses a passive matrix (PMOLED) architecture, not an active matrix (AMOLED). PMOLEDs have a simpler structure: rows and columns are driven directly by the driver chip, and each pixel is lit by applying a current to the intersection of a row and column. The SSD1331 handles this by sequentially scanning the rows (64 rows) and driving the columns (96 columns) with the appropriate voltage for each pixel’s color. The refresh rate is typically 100 Hz, meaning the chip scans all 64 rows 100 times per second, giving a 10 ms scan period per row. The OLED panel’s peak brightness is around 100 cd/m², with a contrast ratio of 10,000:1 (typical for OLEDs). The viewing angle is 160 degrees, and the response time is under 0.1 ms, which is much faster than LCDs. The panel’s lifetime is rated at 10,000 hours to half brightness under typical usage, but this drops if you run it at full brightness continuously.
Now, let’s talk about the power supply requirements. The SSD1331 needs a logic supply voltage (VDD) of 1.65V to 3.5V, and an OLED supply voltage (VCC) of 7V to 15V. The VCC is generated internally by the charge pump, but you need to provide external capacitors: one 1 μF capacitor between VCC and GND, one 10 μF capacitor between VCC and VLSS (analog ground), and one 1 μF capacitor between VDD and VSS. The charge pump efficiency is about 80-85%, so for a 3.3V input, the output current at 12V is limited to about 20 mA. The chip also has a temperature sensor that you can read via command (0x80), which returns a 8-bit value representing the chip temperature in degrees Celsius. This is useful for compensating the OLED brightness over temperature, since OLED efficiency drops at higher temperatures. The typical temperature range is -40°C to +85°C for the driver chip, but the OLED panel itself may have a narrower range (usually -20°C to +70°C).
Let’s get into the command set specifics. The SSD1331 has a “Set Column Address” command (0x15) and “Set Row Address” command (0x75) that define a window for writing pixel data. This is similar to the “set window” function in graphics libraries. You can write pixels sequentially within that window, and the chip auto-increments the column and row pointers. The default window is the full 96x64 matrix, but you can restrict it to a smaller area for faster updates. For example, if you only want to update a 10x10 pixel icon, you set the column range from 0 to 9 and row range from 0 to 9, then send 100 pixels (200 bytes) instead of 12,288 bytes. This cuts update time by a factor of 60. The chip also supports a “Write RAM” command (0x5C) that enters continuous write mode, where you just send pixel data without repeating the command for each byte. This is the most efficient way to update the display.
There’s also a “Set Display Mode” command (0xA4) that switches between normal display, all-on, all-off, and inverse display. The all-on mode lights up every pixel at full brightness, which is useful for testing the panel. The inverse mode flips the pixel data, so white becomes black and vice versa. The “Set Sleep Mode” command (0xAE) puts the chip into a low-power state, drawing less than 1 μA, while the “Normal Display” command (0xAF) wakes it up. The sleep mode is useful for battery-powered devices where you want to turn off the display when not in use. The wake-up time from sleep is about 10 ms, during which the internal charge pump stabilizes.
Now, let’s compare the SSD1331 with other common OLED drivers in a table:
| Driver Chip | Resolution | Color Depth | Interface | Typical Panel Size | RAM Size |
|---|---|---|---|---|---|
| SSD1331 | 96x64 | 16-bit (65k colors) | SPI | 0.95 inch | 12,288 bytes |
| SSD1306 | 128x64 | 1-bit (monochrome) | I2C/SPI | 0.96 inch | 1,024 bytes |
| SH1106 | 132x64 | 1-bit (monochrome) | I2C/SPI | 1.3 inch | 1,056 bytes |
| SSD1351 | 128x128 | 16-bit (65k colors) | SPI | 1.5 inch | 32,768 bytes |
| SSD1327 | 128x128 | 4-bit (16 grays) | SPI/I2C | 1.5 inch | 8,192 bytes |
This table shows that the SSD1331 is unique in its combination of 96x64 resolution and 16-bit color. No other common driver matches this exact spec. The SSD1351 is close but has a higher resolution (128x128) and larger RAM, which makes it more expensive and power-hungry. The SSD1331 is optimized for small, low-cost color displays.
Let’s talk about the physical connections on a typical 0.95-inch 96x64 OLED module. Most modules have a 7-pin or 8-pin header. The 7-pin version includes: VCC (3.3V), GND, SCLK, SDIN, CS, DC, and RST (reset). The 8-pin version adds an extra pin for BS (bus select) or a second SPI data line, but in practice, you only need the 7 pins. The reset pin is active-low and must be held high during normal operation. Some modules also have a built-in level shifter for 5V logic, but the SSD1331 itself is 3.3V only. If you’re using a 5V microcontroller like an Arduino Uno, you need to use level shifters or voltage dividers on the SPI lines to avoid damaging the chip. The chip’s input pins are 5V-tolerant only if VDD is 3.3V, but it’s safer to use a level shifter. The typical input high voltage threshold is 0.8 * VDD, so for 3.3V VDD, you need at least 2.64V for a logic high.
Now, let’s get into the software side. The SSD1331 is supported by several libraries, including Adafruit’s SSD1331 library, which is based on the Adafruit-GFX library. This library provides functions like drawPixel, drawLine, drawRect, fillRect, drawCircle, and drawBitmap. The library handles the SPI communication and command set internally. The initialization sequence for the SSD1331 is specific: you need to send a series of commands to set up the display, including turning off the display, setting the charge pump voltage, setting the display clock divide ratio, setting the segment and COM remap, and then turning the display on. The typical initialization sequence is about 20 commands. Here’s a snippet of the initialization commands in hex:
0xAE (Display OFF)
0xA0, 0x72 (Set Re-map: RGB format, horizontal increment)
0xA1, 0x00 (Set Display Start Line: 0)
0xA2, 0x00 (Set Display Offset: 0)
0xA4 (Normal Display)
0xA8, 0x3F (Set Multiplex Ratio: 64)
The exact sequence varies by module, but the datasheet provides a recommended startup sequence. One common mistake is forgetting to set the “Display ON” command (0xAF) after initialization, which leaves the OLED in sleep mode and shows nothing. Another is setting the contrast too high, which can cause ghosting or burn-in over time.
Let’s talk about the display’s physical characteristics. The 0.95-inch 96x64 OLED has a pixel pitch of about 0.21 mm (calculated as 0.95 inch / 96 pixels * 25.4 mm/inch = 0.251 mm, but the actual pixel size is smaller due to the bezel). The active area is roughly 20.1 mm x 13.4 mm (96 * 0.21 mm = 20.16 mm, 64 * 0.21 mm = 13.44 mm). The module thickness is about 1.2 mm for the glass-based version, or 0.8 mm for the plastic-based version. The glass version has a higher contrast but is more fragile. The module typically comes with a 4-pin or 6-pin flexible flat cable (FFC) that connects to a breakout board. The breakout board has the SSD1331 chip soldered on the back, along with the charge pump capacitors and a few resistors for current limiting. The breakout board’s dimensions are usually 25 mm x 15 mm, which is slightly larger than the display itself.
Now, let’s discuss the electrical characteristics in more detail. The SSD1331’s maximum SPI clock frequency is 20 MHz, but the actual data transfer rate is limited by the chip’s internal processing. The chip has a 16-byte FIFO buffer for incoming SPI data, so you can send data in bursts without waiting for the chip to process each byte. The FIFO depth is 16 bytes, which means you can send up to 16 bytes (8 pixels) before the chip starts to stall. If you send more than 16 bytes without a delay, the chip’s busy flag will go high, and you’ll need to wait for the FIFO to empty. In practice, this means you should either send data in 16-byte chunks or use a hardware SPI controller that handles the flow control. The chip’s typical response time for a command is 1-2 μs, so you don’t need to add delays between commands unless you’re using a very slow microcontroller.
The chip also has a “Clear Screen” command (0x25) that fills the entire RAM with a single color value. This is faster than writing pixels one by one, because you send just one command and the chip handles the rest internally. The command takes about 10 ms to complete, during which the chip is busy and ignores new commands. You can check the busy status by reading the “Status Register” (0x80), but this requires a read operation over SPI, which is not supported on all modules (some modules don’t have a MISO pin). If your module doesn’t have MISO, you’ll need to add a delay after the clear command.
Let’s talk about the color performance. The SSD1331’s 16-bit color depth gives 65,536 colors, which is enough for smooth gradients and photographic images, but not for professional-grade color accuracy. The color gamut is about 60% of the NTSC standard, which is typical for small OLEDs. The white point is around 6,500K (D65) at default settings, but you can adjust it by changing