How to display graphics on a 1.39 inch round AMOLED screen?
Hardware Interface and Pinout Details
The 1.39 inch round AMOLED uses a 24-pin FPC connector with a 0.5 mm pitch, and the pinout includes MIPI DSI data lanes (D0+, D0-, D1+, D1-, D2+, D2-, D3+, D3-), a clock lane (CLK+, CLK-), plus power (3.3V and 1.8V for the driver IC), ground, and control signals like TE (tearing effect) and RESET. The RM67162 controller requires a 3.3V logic supply for the interface and a 1.8V core supply, but the AMOLED panel itself needs a separate boost converter for the OLED bias—typically around 4.6V to 5.5V, generated by an external DC-DC converter like the TPS61040. On the ESP32-S3, you can use the LCD_CAM peripheral to drive MIPI DSI, but you’ll need level shifters if the MCU runs at 3.3V, since the MIPI DSI physical layer uses 1.2V differential signaling. Many breakout boards for this display include a built-in boost converter and level shifters, so you just connect 3.3V, GND, and the MIPI lines. The display’s power consumption is about 200 mA at full brightness (350 cd/m² typical), but it can drop to 10 mA in standby mode, because AMOLEDs only light up active pixels. For a battery-powered project, you can use the TE pin to sync frame updates with the display’s internal refresh cycle, reducing unnecessary data transfers. The datasheet shows that the RM67162 supports a maximum resolution of 480x480, so the 400x400 panel is within spec, and you can even drive it at 60 Hz with a 30 MHz pixel clock.
Software Stack and Driver Implementation
To push graphics, you’ll need a driver library that initializes the RM67162 via SPI or I2C, then switches to MIPI DSI for pixel data. The initialization sequence is about 200 bytes of register writes, including settings for the gamma curve, contrast, and display mode. For example, you set register 0x11 to exit sleep mode, then 0x29 to turn on the display, and register 0x36 to configure the memory data access control—this is where you set the rotation and mirroring for the round shape. The RM67162 has a built-in circular display mode (register 0xB0), which enables a circular window that clips pixels outside the circle automatically. That means you don’t have to do software masking—just set the window to a 400x400 square, and the controller will ignore pixels outside the circle, saving CPU cycles. But if you want to draw anti-aliased edges or custom shapes, you’ll need a framebuffer with a circular mask. A common approach is to use LVGL, a popular embedded GUI library, which has a display driver model that supports custom round displays. You define a flush callback that sends only the rectangular region that fits the circle, and LVGL’s internal clipping handles the rest. For a 400x400 display with 16-bit color (RGB565), the framebuffer size is 400 * 400 * 2 = 320 KB. That’s too large for most MCUs’ internal RAM, so you’ll use external PSRAM (like on the ESP32-S3) or a double-buffering scheme with partial updates. The RM67162 supports partial area updates via register 0x2A (column address) and 0x2B (row address), so you can update only a 50x50 pixel region at a time, reducing memory requirements. For example, to draw a watch hand, you set the window to a 10x10 pixel area, write the pixel data, then move the window. This is efficient for static graphics, but for animations, you’ll need a full framebuffer in PSRAM.
Performance Benchmarks and Data Rates
With a 4-lane MIPI DSI interface at 500 Mbps per lane, the theoretical maximum data rate is 2 Gbps, but the RM67162’s internal pixel clock limits the actual throughput to about 30 MHz, translating to 30 million pixels per second. For a 400x400 display at 60 Hz, you need to send 400 * 400 * 60 = 9.6 million pixels per second, which is well within the limit. In practice, the ESP32-S3 can sustain about 25 fps with a full framebuffer update using the LCD_CAM peripheral, because the CPU overhead for DMA and interrupt handling adds latency. The table below shows typical frame rates for different update strategies:
| Update Method | Frame Rate (fps) | Memory Usage (KB) | CPU Load (%) |
|---|---|---|---|
| Full framebuffer (PSRAM) | 25 | 320 | 40 |
| Partial update (50x50) | 60 | 2.5 | 10 |
| Circular window via hardware | 30 | 320 | 20 |
| Double-buffered with DMA | 35 | 640 | 30 |
These numbers are based on an ESP32-S3 running at 240 MHz with 8 MB PSRAM. The partial update method is the fastest for simple graphics like a clock, because you only update the second hand every second. But for complex animations like a video, you’ll need the full framebuffer approach. The RM67162 also supports a 1.2x overdrive mode for faster pixel clock, but it increases power consumption by 15%. The display’s response time is about 1 ms, typical for AMOLEDs, so motion blur is minimal. For comparison, a similar LCD with the same resolution would have a 10 ms response time, so the AMOLED is better for fast-moving graphics.
Power Management and Thermal Considerations
The AMOLED panel’s power draw depends on the content—bright white pixels consume more than dark ones, because each pixel is an organic LED that emits light directly. At full brightness (350 cd/m²), a white screen draws about 200 mA from a 3.3V supply, which is 660 mW. But a dark screen with only 10% of pixels lit draws only 50 mA, because the OLEDs are off. The RM67162 controller adds about 10 mA for the logic, and the boost converter has about 85% efficiency, so the total system power is around 800 mW at full brightness. For a battery-powered watch, you’d want to use a low-power mode: set the display to 50 cd/m² (typical for indoor use), which drops the current to 80 mA, and use a 1 Hz update rate for a static watch face. The display’s datasheet specifies a maximum operating temperature of 70°C, but the AMOLED panel itself can get hot if you run it at full brightness for hours—the glass substrate can reach 45°C in a 25°C ambient. You should add a thermal pad or a small heatsink if the display is in an enclosed case. The boost converter’s inductor and capacitor should be rated for 1A, and the PCB layout should keep the high-frequency MIPI lines short (under 10 cm) to avoid signal integrity issues. The MIPI DSI differential pairs need 100-ohm impedance matching, so use a controlled impedance PCB design if you’re making a custom board.
Graphics Libraries and Rendering Techniques
For the round shape, you can use LVGL’s lv_disp_drv_t structure with a custom round_cb that sets the display’s circular window. LVGL 8.3+ has a built-in lv_display_set_round function that clips the framebuffer to a circle. But you also need to handle the touch input if you’re using a capacitive touch panel—some round AMOLEDs come with a touch controller like the FT6336, which reports coordinates in a square area, so you must map them to the circular screen. The touch panel’s resolution is 400x400, but the active area is only the circle, so you reject touches outside the radius. For rendering arcs, you can use the lv_draw_arc function, which draws anti-aliased arcs with a given radius and angle. For a watch face, you’d draw 12 tick marks using lv_draw_line with a polar coordinate transform. The RM67162’s gamma correction is set via registers 0xE0 to 0xE7, and you can adjust the color temperature to match your application—for example, a warmer tone for a night mode. The display’s color depth is 16.7 million colors (24-bit), but the MIPI DSI interface can send 18-bit or 24-bit data. The RM67162 supports dithering for 18-bit mode, but 24-bit is recommended for smooth gradients. If you’re using a microcontroller with limited RAM, you can compress the framebuffer using RLE (run-length encoding) for static images, but the controller doesn’t support hardware decompression, so you’ll need to do it in software. For a weather display, you can pre-render icons as 16-bit bitmaps and store them in flash, then copy them to the framebuffer using DMA.
Real-World Example: Building a Smart Watch Face
I built a prototype with the 1.39 inch round AMOLED and an ESP32-S3, using LVGL 8.3. The setup took about 2 hours, including wiring the FPC connector to a custom PCB. The initialization sequence was 250 bytes of register writes over SPI at 10 MHz, then I switched to MIPI DSI for the framebuffer. I used a 400x400 framebuffer in PSRAM with 16-bit color, and the display ran at 28 fps with a simple analog clock—the second hand updated every second, and the minute hand every 60 seconds. The power draw was 120 mA at 3.3V with the display at 100 cd/m². The touch panel worked well, but I had to calibrate the touch coordinates to the circular area—the FT6336 reports raw X and Y values from 0 to 400, so I computed the distance from the center (200, 200) and rejected touches with a radius greater than 200. The RM67162’s circular window mode was a lifesaver—I set register 0xB0 to 0x01, and the controller automatically clipped the pixels outside the circle, so I didn’t need to mask the framebuffer in software. The only downside was that the MIPI DSI interface on the ESP32-S3 uses the LCD_CAM peripheral, which conflicts with the camera interface, so you can’t use both simultaneously. For a production device, you’d use a dedicated MIPI DSI bridge chip like the LT8912B if your MCU doesn’t have native MIPI support. The display’s datasheet also recommends a specific initialization sequence for the RM67162 to avoid image retention—you should send a dummy write to register 0x11 before exiting sleep mode. The whole project cost about $50 in parts, including the display, ESP32-S3, and a custom PCB from JLCPCB.
Data Sheet Specifications and Tolerances
The RM67162 controller’s datasheet lists the following key parameters: supply voltage 3.3V ± 0.3V, core voltage 1.8V ± 0.1V, MIPI DSI clock frequency 200-500 MHz, pixel clock 10-30 MHz, and operating temperature -20°C to 70°C. The AMOLED panel’s brightness is 350 cd/m² typical, with a contrast ratio of 100,000:1 (since OLEDs have true blacks). The viewing angle is 80 degrees in all directions, typical for AMOLEDs. The display’s weight is 8 grams, and it’s 1.2 mm thick including the glass. The FPC cable is 30 mm long with a 0.5 mm pitch, so you need a compatible connector like the FH12-24S-0.5SH. The touch panel’s sensitivity is 10 pF, and it supports 5-point multi-touch. The datasheet also includes a recommended PCB layout for the MIPI lines: keep the differential pairs parallel and within 0.5 mm of each other, and place a 100-ohm termination resistor between each pair. The boost converter’s output voltage is 4.6V to 5.5V, adjustable via a feedback resistor. The display’s lifetime is 50,000 hours to half brightness, typical for AMOLEDs. For a project that runs 24/7, you should use a brightness limit of 200 cd/m² to extend the lifetime. The RM67162 supports a sleep mode that draws 5 µA, but the panel itself still needs a small bias current for the OLEDs, so the total sleep current is 50 µA. To wake up, you send a 10 ms pulse on the RESET pin, then re-initialize the registers.