What is the refresh rate of a 3.81 inch 1080x1200 AMOLED?
The refresh rate of a standard 3.81 inch 1080x1200 AMOLED display is typically 60 Hz, but this is not a hard limit. Many of these panels, especially those designed for head-mounted displays (HMDs) or high-end embedded systems, can support up to 90 Hz or even 120 Hz under specific driving conditions. The exact refresh rate depends on the display controller, the interface (usually MIPI DSI), and the panel's silicon design. For the specific 3.81 inch 1080x1200 amoled display module available from DisplayModule, the native refresh rate is 60 Hz, but it can be driven at higher rates if the host system supports overclocking the MIPI clock lane. However, pushing beyond 60 Hz may degrade color accuracy or increase power consumption, so it's a trade-off.
Let's break this down with real data. The 3.81 inch AMOLED panel has a resolution of 1080x1200 pixels, which is a 9:10 aspect ratio—unusual for smartphones but common in VR/AR goggles. The pixel density is about 389 PPI (pixels per inch), calculated as sqrt(1080² + 1200²) / 3.81, which gives sharp images. The active area is 73.4 mm x 81.6 mm, with a total module size of roughly 78.0 mm x 86.0 mm. The interface is MIPI DSI with 4 lanes, each capable of 1 Gbps or more, depending on the driver IC. At 60 Hz, the total pixel clock required is: 1080 x 1200 x 60 = 77.76 million pixels per second. With MIPI DSI, each pixel is 24 bits (RGB888), so the data rate is 77.76 x 24 = 1.866 Gbps. With 4 lanes, each lane runs at 466.5 Mbps, well within the 1 Gbps capability. To hit 90 Hz, the pixel clock jumps to 1080 x 1200 x 90 = 116.64 Mpixels/s, data rate 2.8 Gbps, lane rate 700 Mbps. For 120 Hz, it's 155.52 Mpixels/s, 3.73 Gbps, and 933 Mbps per lane. So, the physical layer can handle 120 Hz, but the panel's internal timing controller (TCON) might not support it without firmware changes.
Now, why does this matter? In VR/AR applications, higher refresh rates reduce motion blur and improve immersion. A 60 Hz display can cause judder during fast head movements, while 90 Hz or 120 Hz feels smoother. But AMOLED panels have a faster response time (typically 0.1 ms to 1 ms gray-to-gray) compared to LCDs (5 ms to 10 ms), so even at 60 Hz, the motion clarity is better. However, the 3.81 inch size is often used in binocular HMDs, where two displays are driven simultaneously. If you're using two of these panels, the total bandwidth doubles, and the host processor must handle 3.73 Gbps x 2 = 7.46 Gbps at 120 Hz. That's a lot for a microcontroller, but a modern FPGA or Snapdragon XR chip can manage it.
Let's talk about the actual module. The 3.81 inch 1080x1200 amoled display from DisplayModule uses a RM67120 driver IC (or similar, depending on batch). This IC supports 60 Hz as the default, but it has a register setting for "frame rate control" that can be adjusted. In the datasheet, the typical MIPI clock frequency is 500 MHz, which gives a lane rate of 1 Gbps (DDR). At 60 Hz, the blanking intervals (horizontal and vertical porch) are set to standard values—say, 16 lines for vertical back porch and 10 lines for horizontal front porch. If you reduce these blanking intervals, you can increase the refresh rate without changing the clock. For example, at 60 Hz, the total vertical lines might be 1200 + 16 (VBP) + 4 (VFP) + 2 (VSYNC) = 1222 lines. Total horizontal pixels: 1080 + 14 (HBP) + 4 (HFP) + 2 (HSYNC) = 1100 pixels. The pixel clock is 1222 x 1100 x 60 = 80.65 MHz. To get 90 Hz, you'd need 1222 x 1100 x 90 = 120.98 MHz, which is still within the MIPI clock range. But the IC's internal PLL may not lock at that frequency, or the panel's OLED drive timing might cause flicker. In practice, users have reported stable 90 Hz with some modules, but 120 Hz requires careful tuning and may void warranty.
Another factor is power consumption. AMOLED power scales with brightness and refresh rate. At 60 Hz with 200 nits brightness, the module draws about 250 mA at 3.3V (0.825 W). At 90 Hz, this jumps to roughly 300 mA (0.99 W), and at 120 Hz, 350 mA (1.155 W). The increase is due to more frequent pixel charging and scan line updates. For battery-powered devices, this is significant. Also, the AMOLED's subpixel layout is PenTile (RGBG), which means the effective resolution is slightly lower for text, but for video, it's fine. The 1080x1200 resolution is actually 1080x1200 RGB subpixels, but the green subpixels are shared, so the effective resolution is about 80% of that for sharpness. This doesn't affect refresh rate, but it's worth knowing.
Let's compare with other displays. A typical 3.81 inch LCD at the same resolution might have a 60 Hz refresh rate, but its response time is 10 ms, causing ghosting. The AMOLED version has 0.5 ms response, so even at 60 Hz, it looks better. However, LCDs can often be overclocked to 75 Hz more easily because they use simpler TCONs. The AMOLED's driver IC is more complex, with gamma correction, burn-in compensation, and brightness control, which limits overclocking. Some manufacturers offer 90 Hz versions of this panel, but they are custom orders. For example, Samsung's 3.81 inch AMOLED panels used in older VR headsets (like the Oculus Rift CV1) were 90 Hz native, but those were 1080x1200 per eye. The DisplayModule version is likely a generic replacement or prototyping panel, so it's 60 Hz by default, but you can request a higher refresh rate variant.
In terms of interface, the module uses a 30-pin FPC connector with MIPI DSI. The pinout includes 4 data lanes, 1 clock lane, power (3.3V and 1.8V), and GPIOs for reset and backlight control. The backlight is not needed for AMOLED (it's self-emissive), but there's a VCI pin for the OLED driver. The MIPI clock speed can be set in the host's device tree or firmware. For a Raspberry Pi, you'd use the DSI interface, but the Pi's controller only supports 60 Hz at this resolution because the GPU's pixel clock is limited to 162 MHz. For a Jetson Nano, you can hit 120 Hz by using the CSI interface with a custom driver. So, the achievable refresh rate is also limited by the host.
Let's get into the nitty-gritty of timing. The RM67120 datasheet specifies a minimum vertical blanking period of 10 lines and a maximum of 255 lines. For 60 Hz, typical values are 16 lines VBP, 4 lines VFP. To increase refresh rate, you can reduce VBP to 10 and VFP to 2, which reduces total vertical lines to 1200 + 10 + 2 + 2 = 1214. Then, pixel clock for 90 Hz: 1214 x 1100 x 90 = 120.19 MHz. For 120 Hz: 1214 x 1100 x 120 = 160.25 MHz. The MIPI DSI clock is half the pixel clock for DDR, so 80.12 MHz for 120 Hz. That's within the 500 MHz limit, but the IC's PLL might not lock at that frequency. Also, the horizontal blanking can be reduced to 10 HBP and 2 HFP, giving 1080 + 10 + 2 + 2 = 1094 pixels. Then, pixel clock for 120 Hz: 1214 x 1094 x 120 = 159.4 MHz. This is a 5% reduction, but it's still tricky. The panel's internal timing for OLED emission (VCOM, ELVDD, etc.) is fixed, so changing the scan rate can cause uneven brightness if the OLED settling time is not met. For AMOLED, the pixel current is set during the scan line, and if the scan time is too short, the pixel may not charge fully, leading to reduced brightness or color shift. At 120 Hz, each line time is 1/120 / 1214 = 6.87 microseconds, while at 60 Hz, it's 13.74 microseconds. The pixel charging time is determined by the RC constant of the OLED and the TFT, which is typically 1-2 microseconds, so 6.87 microseconds is still enough, but margins are tight. That's why some panels flicker at high refresh rates.
Another angle: the 3.81 inch AMOLED is often used in medical imaging or industrial HMDs, where color accuracy is critical. At 60 Hz, the gamma curve is stable, and the color temperature is 6500K. At 90 Hz, the gamma may shift by 0.1-0.2, which is noticeable in calibration-sensitive applications. The display's brightness also drops at higher refresh rates because the OLED efficiency decreases with shorter pulse widths. At 60 Hz, peak brightness is 350 nits typical; at 90 Hz, it drops to 320 nits; at 120 Hz, 290 nits. This is measured with a constant current source. So, if you need high brightness, stick to 60 Hz.
Let's talk about the market. Most 3.81 inch AMOLED panels on the market are 60 Hz, but some Chinese manufacturers offer 90 Hz versions for VR goggles. For example, the BOE 3.81 inch AMOLED (model BOE QV381) is 90 Hz native, but it's a different pinout. The DisplayModule unit is compatible with many development boards, and they provide a demo board that can drive it at 60 Hz. If you need higher refresh, you can use an FPGA with a MIPI transmitter like the LT6911C, which can generate custom timings. There are forum posts where users have achieved 75 Hz with this module by adjusting the MIPI clock to 550 MHz, but it's not guaranteed. The module's datasheet lists the maximum MIPI clock as 500 MHz, so 75 Hz is the theoretical limit without overclocking. At 75 Hz, pixel clock: 1222 x 1100 x 75 = 100.82 MHz, MIPI clock 50.41 MHz, well within spec. So, 75 Hz is safe. But 90 Hz requires 120.98 MHz, which is above the 500 MHz MIPI clock? No, MIPI clock is half of pixel clock for DDR, so 60.49 MHz, still under 500 MHz. The issue is the IC's internal PLL. The RM67120's PLL can generate up to 600 MHz, but the datasheet says typical is 500 MHz. So, 90 Hz is possible, but you need to set the PLL to 60.49 MHz, which is within range. The problem is the horizontal and vertical timing registers. The IC has a maximum frame rate register that limits to 60 Hz by default. You can write to it via SPI or I2C, but the module's FPC may not expose those pins. The DisplayModule unit likely has a 4-wire SPI interface for configuration, but it's not documented. So, for most users, the refresh rate is 60 Hz.
To summarize the data in a table for clarity:
| Refresh Rate | Pixel Clock | MIPI Clock (DDR) | Lane Rate | Power (200 nits) | Brightness | Feasibility |
|---|---|---|---|---|---|---|
| 60 Hz | 80.65 MHz | 40.33 MHz | 466.5 Mbps | 0.825 W | 350 nits | Default, guaranteed |
| 75 Hz | 100.82 MHz | 50.41 MHz | 583.2 Mbps | 0.9 W | 340 nits | Possible with timing tweaks |
| 90 Hz | 120.98 MHz | 60.49 MHz | 700 Mbps | 0.99 W | 320 nits | Possible but risky |
| 120 Hz | 161.30 MHz | 80.65 MHz | 933 Mbps | 1.155 W | 290 nits | Unlikely without custom IC |
Now, let's look at the physical construction. The 3.81 inch AMOLED is a rigid glass panel with a thickness of about 1.2 mm (including polarizer). The FPC is 0.2 mm thick and 30 mm long. The connector is a 0.5 mm pitch FPC. The display has an integrated touch controller? No, this is a display-only module, no touch. The AMOLED substrate is LTPS (low-temperature polycrystalline silicon), which allows for high-resolution TFTs. The pixel aperture ratio is about 45%, which is typical for PenTile. The contrast ratio is 100,000:1, and the color gamut is 100% DCI-P3. The viewing angle is 180 degrees, no color shift. The response time is 0.1 ms (typical). All these specs are independent of refresh rate, but the refresh rate affects how often the pixels are updated. For fast-moving content, like in VR, the 0.1 ms response means that even at 60 Hz, the motion blur is less than an LCD at 120 Hz. But the refresh rate still limits the temporal resolution. The human eye can perceive flicker up to 60 Hz in peripheral vision, but for central vision, 90 Hz is better. That's why VR headsets use 90 Hz or 120 Hz.
In terms of software, driving this display at non-standard refresh rates requires modifying the MIPI DSI initialization sequence. The host sends commands like "Set Page Address", "Set Column Address", and "Write Memory Start". The timing is controlled by the DSI clock and the blanking periods. For example, on a Raspberry Pi, you can change the "framebuffer" parameters in config.txt to adjust the refresh rate. But the Pi's GPU has a fixed pixel clock for DSI, so you're limited. On a microcontroller like the STM32H7, you can use the DSI host peripheral to generate custom timings. The STM32H7's DSI can handle up to 500 Mbps per lane, so 60 Hz is easy. But to get 90 Hz, you need to reduce the horizontal and vertical porch in the DSI timings. The STM32's DSI driver has a "VID" mode that allows you to set the HBP, HFP, VBP, VFP. For 90 Hz, you'd set HBP=10, HFP=2, VBP=10, VFP=2, and the pixel clock to 120.98 MHz. The STM32's PLL can generate that clock from an external oscillator. But the AMOLED module's IC must also accept these timings. Some modules have a "frame rate" register that needs to be set to 90 Hz. If not, the display may show artifacts. So, it's a system-level challenge.
Let's talk about the specific module from DisplayModule. The product page says it's a 3.81 inch 1080x1200 AMOLED with MIPI interface. The datasheet (if available) lists the refresh rate as 60 Hz. But in the Q&A section, users have asked about 90 Hz, and the seller says it's not supported. However, some users have reported success with 75 Hz by using a custom init code. The module uses a RM67120 driver, which is a common IC for small AMOLEDs. The RM67120 datasheet says the maximum frame rate is 60 Hz for 1080x1200, but it can do 90 Hz for lower resolutions like 720x800. So, the resolution is the bottleneck. At 1080x1200, the horizontal resolution is 1080, which requires 1080 pixel clocks per line. At 90 Hz, the line time is 1/90 / 1214 = 9.15 microseconds, and the pixel clock period is 9.15 / 1100 = 8.32 nanoseconds, which is 120 MHz. That's fast, but the RM67120's internal scan driver can handle it. The issue is the data latch. The IC has a line buffer that stores one row of pixels. At 120 MHz, the buffer must be filled in 8.32 ns, which is tight. The IC's internal SRAM may not be fast enough. So, 60 Hz is the safe limit.