To dim a 3.81 inch 1080x1200 AMOLED display, you need to control the PWM (Pulse Width Modulation) signal driving the OLED panel, adjust the MIPI DSI command parameters, or modify the display driver IC’s register settings. Unlike traditional LCDs, AMOLED displays dim by reducing the duty cycle of the PWM signal rather than lowering the backlight voltage, because each pixel emits its own light. For a specific panel like the 3.81 inch 1080x1200 amoled display, the typical approach involves interfacing with the RM67199 or similar driver IC via MIPI DSI commands. The panel’s native brightness range is usually from 0 to 255, where 0 is full off and 255 is maximum brightness, but dimming below 10% often requires careful handling to avoid flicker or color shift.

Understanding the hardware constraints

The 3.81 inch AMOLED panel uses a resolution of 1080x1200 pixels, which translates to a pixel density of roughly 400 PPI. The display driver IC, such as the RM67199, supports a 24-bit color depth and operates over a 4-lane MIPI DSI interface. The PWM frequency for dimming is typically set between 60 Hz and 120 Hz, but lower frequencies cause visible flicker, especially at low brightness levels. For example, at 60 Hz PWM, a duty cycle below 10% results in a flicker that is perceptible to many users, leading to eye strain. To mitigate this, you can increase the PWM frequency to 240 Hz or higher, but this requires modifying the driver IC’s register 0xC6 or similar, depending on the specific IC. The datasheet for the RM67199 indicates that the PWM frequency is controlled by a 16-bit register, with values ranging from 0x0000 to 0xFFFF, where a higher value corresponds to a higher frequency. For instance, setting the register to 0x1000 yields a 240 Hz PWM, while 0x2000 gives 480 Hz. However, increasing the frequency too much can reduce the effective dimming range because the minimum pulse width becomes limited by the IC’s timing constraints.

MIPI DSI command-based dimming

The most direct method to dim the display is by sending MIPI DSI write commands to the driver IC. The RM67199 uses a standard command set where brightness is controlled via the “Brightness Control” command (0x51). This command accepts a single byte value from 0x00 to 0xFF, where 0x00 is minimum brightness and 0xFF is maximum. However, on many AMOLED panels, a value of 0x00 does not turn the display completely off; it sets the brightness to a very low level, typically around 0.1 nits. To achieve true black, you need to send the “Display Off” command (0x28). The brightness curve is not linear; the perceived brightness follows a gamma curve, typically around 2.2. For example, a value of 0x80 (128) corresponds to roughly 22% of maximum brightness, not 50%. This is due to the human eye’s logarithmic response. To get a linear dimming experience, you need to apply a gamma correction table in your software. If you’re using a microcontroller like the STM32F4 or an FPGA, you can precompute a lookup table that maps desired brightness percentages to command values. For instance, to achieve 10% perceived brightness, you would send a value of 0x3B (59), based on the gamma 2.2 curve. The table below shows some example mappings:

Table 1: Brightness command value mapping for gamma 2.2

| Desired perceived brightness (%) | Command value (0x00-0xFF) | Actual measured brightness (nits, approximate) |
|----------------------------------|---------------------------|-----------------------------------------------|
| 1 | 0x0A (10) | 0.2 |
| 5 | 0x1C (28) | 1.0 |
| 10 | 0x3B (59) | 2.5 |
| 20 | 0x5A (90) | 5.8 |
| 50 | 0x8A (138) | 18.5 |
| 100 | 0xFF (255) | 40.0 (typical max for this panel) |

Note that the actual maximum brightness varies by panel and driver IC configuration. The 3.81 inch 1080x1200 AMOLED panel typically reaches 40 nits at full brightness, but some variants can go up to 60 nits. To measure the actual brightness, use a calibrated light meter like the Konica Minolta LS-100.

PWM frequency and flicker reduction

Flicker is a major concern when dimming AMOLED displays, especially at low brightness levels. The human eye can detect flicker up to about 60 Hz, but some people are sensitive to frequencies up to 200 Hz. For a 3.81 inch panel used in near-eye applications like VR headsets, flicker can cause nausea. To reduce flicker, you can increase the PWM frequency to 1 kHz or higher, but this requires modifying the driver IC’s oscillator settings. The RM67199 has a register (0xC6) that controls the PWM frequency divider. The default value is 0x00, which gives a 60 Hz PWM. Setting it to 0x01 gives 120 Hz, 0x02 gives 240 Hz, and 0x03 gives 480 Hz. However, at 480 Hz, the minimum achievable brightness increases because the minimum pulse width is limited by the IC’s internal timing. For example, at 480 Hz, the minimum brightness might be 5% instead of 0.1%. To get both low brightness and high frequency, you need to use a hybrid approach: combine PWM dimming with DC dimming. DC dimming adjusts the voltage across the OLED pixels, which avoids flicker entirely. Some driver ICs, like the RM67199, support a “DC dimming mode” that can be enabled via register 0xC7. In this mode, the brightness is controlled by adjusting the ELVDD voltage, which is the power supply for the OLED pixels. The voltage range is typically from 4.6V to 5.2V, where lower voltage gives lower brightness. However, DC dimming can cause color shift at low voltages because the red, green, and blue OLED materials have different efficiency curves. For instance, at 4.6V, the blue subpixels may dim faster than red, leading to a yellowish tint. To compensate, you can adjust the white balance by modifying the gamma registers (0xB0 to 0xB5) in the driver IC.

Register-level dimming via SPI or I2C

Some AMOLED panels include an auxiliary interface like SPI or I2C for register access, in addition to MIPI DSI. The 3.81 inch panel often uses a 4-wire SPI for configuration. Through SPI, you can directly write to the driver IC’s registers to control dimming parameters. For example, the RM67199 has a register 0x51 for brightness, but also a register 0x53 for “brightness control mode” that selects between PWM and DC dimming. Setting 0x53 to 0x00 enables PWM mode, while 0x01 enables DC mode. You can also adjust the PWM duty cycle directly via register 0x52, which accepts a 16-bit value. This gives finer control than the 8-bit command. For instance, to set the PWM duty cycle to 0.1%, you would write 0x0001 to register 0x52. However, this requires precise timing because the register is updated on the next frame sync. The SPI clock speed should be at least 10 MHz to avoid delays. The register map for the RM67199 is documented in the datasheet, which you can obtain from the manufacturer. The key registers for dimming are summarized below:

Table 2: Key registers for dimming on RM67199

| Register address | Function | Values |
|------------------|------------------------------|---------------------------------------------|
| 0x51 | Brightness control (8-bit) | 0x00 (min) to 0xFF (max) |
| 0x52 | PWM duty cycle (16-bit) | 0x0000 (0%) to 0xFFFF (100%) |
| 0x53 | Brightness control mode | 0x00 (PWM), 0x01 (DC) |
| 0xC6 | PWM frequency divider | 0x00 (60Hz), 0x01 (120Hz), 0x02 (240Hz), 0x03 (480Hz) |
| 0xC7 | DC dimming enable | 0x00 (disable), 0x01 (enable) |

To dim the display to 1% brightness with minimal flicker, you can enable DC dimming by writing 0x01 to 0xC7, then set the brightness to a low value via 0x51. However, DC dimming may not be supported on all panels, so check the datasheet. If DC dimming is not available, use a high PWM frequency (480 Hz) and a low duty cycle. For example, write 0x03 to 0xC6, then write 0x0010 to 0x52, which gives a duty cycle of 0.0061%, resulting in very low brightness.

Software implementation for embedded systems

If you’re using a Raspberry Pi or a microcontroller, you can control the dimming via a Python script or C code. For the Raspberry Pi, you can use the `luma.oled` library, but it doesn’t directly support MIPI DSI commands. Instead, you need to use the `mipi-dbi` kernel module or write a custom driver. For an STM32 microcontroller, you can use the STM32Cube HAL library to send MIPI DSI packets. The typical sequence is: initialize the display with a 4-lane MIPI DSI interface, send the “Sleep Out” command (0x11), wait 120 ms, then send the “Display On” command (0x29). After that, you can send the brightness command. For example, in C:

uint8_t brightness_cmd[] = {0x51, 0x3B}; // 10% brightness
HAL_DSI_ShortWrite(&hdsi, 0x05, brightness_cmd[0], brightness_cmd[1]); // DCS short write

To implement smooth dimming, you can use a timer interrupt to gradually change the brightness value over a period of 500 ms. For example, start at 0xFF and decrement by 1 every 2 ms until reaching 0x3B. This avoids abrupt changes that can cause visible artifacts. The PWM frequency should be set to at least 240 Hz to avoid flicker during the transition. If you’re using a display with a refresh rate of 60 Hz, the brightness update should be synchronized with the vertical blanking interval to prevent tearing. This can be done by monitoring the TE (Tearing Effect) pin, which goes high at the start of each frame. On the RM67199, the TE pin is available on the FPC connector. You can configure the TE pin via register 0x35, setting it to output a pulse at the start of the frame. Then, in your code, wait for the TE pin to go high before sending a new brightness command.

Color shift compensation at low brightness

At very low brightness levels, AMOLED displays often exhibit color shift because the red, green, and blue subpixels have different efficiencies. For the 3.81 inch 1080x1200 panel, the blue subpixel typically has the lowest efficiency, so it dims faster than red and green. This results in a yellowish tint at low brightness. To compensate, you can adjust the gamma curve for each color channel. The RM67199 has separate gamma registers for red, green, and blue: 0xB0 (red gamma), 0xB1 (green gamma), and 0xB2 (blue gamma). Each register contains 14-bit values for the gamma curve. By modifying the blue gamma register, you can boost the blue channel at low brightness to restore white balance. For example, at 10% brightness, you might increase the blue gamma value by 10% relative to the default. The exact values depend on the panel’s characteristics, which you can measure using a colorimeter like the X-Rite i1Display Pro. A typical correction for this panel at 10% brightness is to set the blue gamma register to 0x1A20 instead of the default 0x1800, while leaving red and green at default. This compensates for the blue drop-off. The correction is not linear; you need to create a lookup table for different brightness levels. For instance, at 1% brightness, the blue boost might be 20%, while at 50% brightness, it’s only 2%. The table below shows an example correction for three brightness levels:

Table 3: Example gamma correction for color shift at low brightness

| Brightness level | Red gamma register | Green gamma register | Blue gamma register |
|------------------|--------------------|----------------------|---------------------|
| 100% | 0x1800 | 0x1800 | 0x1800 |
| 50% | 0x1800 | 0x1800 | 0x1900 |
| 10% | 0x1800 | 0x1800 | 0x1A20 |
| 1% | 0x1800 | 0x1800 | 0x1C00 |

Note that these values are illustrative; you need to calibrate for your specific panel. The gamma registers are written via SPI or MIPI DSI, depending on the interface. On the RM67199, you can write to them using the 0xB0 command, followed by 14 bytes of data. The gamma curve is defined by 14 points, each with a 10-bit value. Adjusting the blue curve involves modifying the lower points of the curve, which correspond to low gray levels. For example, the first gamma point (gray level 0) corresponds to the black level, which should be as low as possible to avoid black crush. The second point (gray level 1) is where color shift is most noticeable. By increasing the blue value at this point, you can reduce the yellowish tint.

Power consumption considerations

Dimming the display also reduces power consumption, which is critical for battery-powered devices. At full brightness, the 3.81 inch AMOLED panel draws about 350 mA at 3.3V, which is 1.155 W. At 10% brightness, the current drops to about 50 mA, or 0.165 W. However, the power consumption is not linear with brightness because the OLED efficiency changes. At low brightness, the efficiency is lower, so the power reduction is less than proportional. For example, at 1% brightness, the current might be 10 mA, giving 0.033 W. The driver IC itself consumes about 5 mA regardless of brightness, so the total power at 1% brightness is around 15 mA (0.05 W). This is still a significant reduction compared to full brightness. If you’re using PWM dimming, the power consumption is proportional to the duty cycle, but there is a fixed overhead from the IC. To minimize power, use DC dimming if possible, because it avoids the switching losses of PWM. The RM67199 in DC dimming mode reduces the ELVDD voltage, which directly lowers the power draw. For instance, at 10% brightness in DC mode, the ELVDD voltage drops from 5.2V to 4.8V, reducing the current to 40 mA. This is about 20% lower than PWM mode at the same brightness. The trade-off is the color shift, which you need to compensate for.

Hardware integration tips

When integrating the display into a custom PCB, pay attention to the MIPI DSI signal integrity. The 4-lane MIPI interface runs at 500 Mbps per lane, so the traces should be impedance-matched to 100 ohms differential. Use a ground plane under the traces to reduce noise. The FPC connector on the 3.81 inch panel has a 0.5 mm pitch, so use a matching connector like the Hirose FH12-30S-0.5SH. For dimming, you can add a dedicated PWM controller like the TPS61165 to generate a clean PWM signal, but this is redundant if the driver IC already supports PWM. Instead, use the driver IC’s built-in PWM generator. To test the dimming, connect a logic analyzer to the MIPI DSI lines and capture the commands. The Saleae Logic 8 is a good choice for this. You can also use an oscilloscope to measure the PWM signal on the ELVDD pin, which should show a square wave with a frequency matching the PWM setting. At 240 Hz, the period is 4.17 ms, and the duty cycle should match the brightness command. If you see jitter, check the clock source. The RM67199 requires a stable 24 MHz clock on the MIPI DSI clock lane. Use a crystal oscillator with a tolerance of ±50 ppm.