Driving a round AMOLED display

[Minyiky]

Hi there,

I am relatively new to the world of microcontrollers but have had a little bit of experience with displays as I have cobbled together / adapted a driver for an ili9341 adafruit SPI display.

Moving on from this I have my sights set a bit higher but want to check whether what I am thinking is possible and if anyone has any of the information I can't find.

I am looking to use a round AMOLED display with an ESP32 and have found 2 basic options (with a 3rd that is slightly different). I have found some displays based on an RM69330 display driver (such as this: https://www.alibaba.com/product-detail/1-39-inch-ips-454x454-rohs_62286293416.html) which seems to support MIPI and SPI, which seems to be backed up by the vague pinouts I have seen that have SPI labled pins. The other lookks to be driven by an RM69080 display driver that only appears to have MIPI pinouts and so wouldn't be suitable to be used with an ESP32. As another option there is something like this larger screen that appears to support SPI/RGB: https://www.szmaclight.com/product/round-lcd-display-2-1-tft-480x480-RGB.html

One problem I am running into is that I cannot find a datasheet for the RM69330, or any written drivers, which would make it very difficult to use the screen.

Additionally I am not sure what I would need to plan in terms of additional components (resistors, capacitors, etc.) to use the screen as I assume they would be needed.

Does any one have any experience with any of these screens or know of anywhere with a write up or code detailing them?

Thanks in advance for any advice you might have.

[Lindley]

Hi,

Not sure why you had to "cobble together/adapt" a driver for an ili9341 spi display as the adafruit libraries are quiet complete ?

Same with the ili9341 touch screen library, this works well with the ESP32  - #include "XPT2046_Touchscreen.h"

Not sure of you need for those small screens only the RM69330 appears to be SPI comptible, but like many such screens , unless someone has written an Arduino library for them they  are non starters, though you could try  to write your own,  such displays usually have quiet common fuctions, its often just the initialising routine that needs to be tweaked.

If they are cheap enough you often find someone will  produce a library and hardware details, though don't hold your breath on those.

If you search the web you will find a few popular Nokia screens with code for the Arduino,  or like in the Arduino forum there are also details for the Nextion screens if you want more detailed  screen animation.

eg  - https://randomnerdtutorials.com/guide-for-oled-display-with-arduino/

[Minyiky]

Hi Lindley,

The reason I had to cobble one together is that I am using micropython rather than c, and was using it with a particular GUI so had to write functions compatible with that. I did partly base it on the arduino drivers as they were well documented.

I am looking at writting a driver but without the datasheet I don't see it being possible, hence asking if anyone had found one for it.

[Lindley]

Hi,

Think you would will be on a hard slog with those displays, seems no one else can offer any help from all your other forum posts;   cannot you use something more well documented like that little Oled on  that  RN site ?

Also with the displays you show they have such small smd connectors they will be a problem to find and use.

Might be worth adding C++ to your skillset as so much tft and esp32 work is being done based on the Arduino code, so much easier surely ?

[SiliconWizard]

Couldn't find a datasheet for the RM69330 either. As you can see on the product's page, this display panel is IMO clearly not made for hobbyists - you can even ask for customization. Apart from the controller's datasheet, you'd need the panel's specs and the pinout anyway.
That said, as they sell it by 1 unit, you should be able to get documentation. Have you simply asked the seller for that?

[RES]

https://www.usmicroproducts.com/sites/default/files/USMP-A014-045045NEI-A0%28191024%29-v2.pdf

[amyk]

The datasheet appears to be in Chinese:

https://www.ziyan.cc/read-82973.html
https://download.csdn.net/download/qq_38390060/12839943

If you thought this is going to be in any way similar to an ILI9341 or similar display controller with a framebuffer built in, you're in for a surprise: like most other MIPI displays, this is a scan-line type controller that relies on being fed a constant video signal.

[RoadRunner]

I have had some experience driving small MIPI display with SPI to MIPI bridge using a lattice FPGA.

https://www.circuitvalley.com/2020/01/spi-mipi-bridge-fpga-verilog-hdl-ipod-nano-nano-lcd-iphone-mipi-lcd.html

You can drive mipi with fast SPI. Using external divider on clock signal to get DDR signal and appropriate resistors to get the correct voltage level.

Regards

[SiliconWizard]

Note that the recent RPi's support MIPI displays. But first thing would be to figure out the pin-out of this display module and make the proper adapter, as the connectors are definitely not the same.
Also, I don't know how to configure MIPI display output on RPi, but that info may be available somewhere.

Some MCUs also support MIPI DSI. That's most often available on the larger SOCs such as those on the RPi's, but the STM32F469, for instance, supports MIPI.

[RoadRunner]

Note that the recent RPi's support MIPI displays. But first thing would be to figure out the pin-out of this display module and make the proper adapter, as the connectors are definitely not the same.
Also, I don't know how to configure MIPI display output on RPi, but that info may be available somewhere.

Some MCUs also support MIPI DSI. That's most often available on the larger SOCs such as those on the RPi's, but the STM32F469, for instance, supports MIPI.

Raspberry has MIPI DSI output, but only official raspberry pi display or exact same display from other source will work. its locked in closed source GPU firmware, as far as i know resolution is also locked to 800x600,  so getting any other display work with RPI is going to be hard.

if want to drive just by MCU then taking a MCU with mipi output or using SPI with external logic to generate DDR should do.

Regards

[Nominal Animal]

If you want to set your sights a bit lower, BuyDisplay.com aka EastRising has a pretty nice 1.28" 240×240 IPS round display with a GC9A01 controller and documentation (module, panel, panel).  It's rather similar to ILI and SD display controllers, so you shouldn't have any issues getting these to work.

I like BuyDisplay/EastRising, because the display modules are not expensive, they have the documentation on the product page, and have real-world videos of their products on their Youtube channel.

[JPortici]

I can vouch for that display.
Pretty good, though i'd prefer it came with parallel interface, or at least a way  to probe the TE pin

[SiliconWizard]

If you want to set your sights a bit lower, BuyDisplay.com aka EastRising has a pretty nice 1.28" 240×240 IPS round display with a GC9A01 controller and documentation (module, panel, panel).  It's rather similar to ILI and SD display controllers, so you shouldn't have any issues getting these to work.

I like BuyDisplay/EastRising, because the display modules are not expensive, they have the documentation on the product page, and have real-world videos of their products on their Youtube channel.

Yes, this display is not quite as nice, not AMOLED, lower res. But I have good experience with EastRising. The displays are good, and support is too. I once requested tech support for one of their OLED displays, and got a pretty timely answer.

[bzlabs]

I am looking to use a round AMOLED display with an ESP32 and have found 2 basic options (with a 3rd that is slightly different). I have found some displays based on an RM69330 display driver (such as this: https://www.alibaba.com/product-detail/1-39-inch-ips-454x454-rohs_62286293416.html) which seems to support MIPI and SPI, which seems to be backed up by the vague pinouts I have seen that have SPI labled pins. The other lookks to be driven by an RM69080 display driver that only appears to have MIPI pinouts and so wouldn't be suitable to be used with an ESP32. As another option there is something like this larger screen that appears to support SPI/RGB: https://www.szmaclight.com/product/round-lcd-display-2-1-tft-480x480-RGB.html

One problem I am running into is that I cannot find a datasheet for the RM69330, or any written drivers, which would make it very difficult to use the screen.

Apologies for reviving an old thread, but I've recently been going down this same path, as you can find those AMOLED screens for < $20 shipped, which would make them amazing for ESP32 projects if possible to connect and drive them.

I've had a little luck tracking down some info so I figured I'd share what I've found so far in case it's useful to others.

I got a RM69330 "User Guide" from messaging a seller on Ali and asking for datasheets, though it seems to be focused on manufacturers of displays as the "user" rather than application engineers. As far as I can tell it's mainly documentation of a bunch of registers (that I believe are one-time-programmable?) for things like panel configuration, charge pump settings, etc. Generally it does not seem useful to me, as I assume the drivers should already have these values programmed appropriately by the panel manufacturer.

Of more interest though, I noticed that Ambiq had published release notes for their SDK indicating they added driver support for RM69330, which led me to finding this driver implementation for Ambiq MCUs which uses SPI. There's a lot of potentially good stuff there (and in the .h file) including code that initializes the driver IC, and there's good documentation about how to configure SPI. I'm not familiar with Ambiq's SDK, but if I'm reading it correctly, I think I'm seeing several different configurations for either single SPI (SerialCE0DisplayMSPICfg) or quad SPI (QuadCE0DisplayMSPICfg). One potential concern I see is that their driver sets the SPI clock to 48MHz, which is a bit daunting to me in terms of data integrity if I throw together a cheap test PCB, but since it's SPI, it would hopefully be possible to just slow that down to something more hobbyist friendly while initially trying to get it to work.

There seem to be multiple similar models of 1.39" AMOLED panels based on the RM69330 driver available, so for clarity, I'm focusing on the panel that's marketed as a Huawei GT2 46mm smart watch screen replacement, which came marked "FP10128WA" but I believe also can be found as "wb014znm-t00-6dp0". These panels seem pretty readily available, and also come bonded to glass/bezel and includes a touch digitizer, which would be useful in the future if I can ever get the display working. One difference I've seen on spec sheets for similar displays is the connector. Some datasheets I've come across seem to indicate a YXT-BB1F connector with a 0.4mm pitch, but the GT2 46mm display connector appears to be 0.35mm pitch using calipers, and if the spec sheet I found is the correct one, that would be a BM28U-24DP_2-0.35V(86)_2D_SPE connector. I've got the mating connector on the way from digikey, and will update when I find out whether it's correct or not.

For that specific model of display, and again assuming I'm looking at the correct spec sheet, a few things stood out to me:

• VDDIO is listed as 1.8V typical, 1.95V max, so would need high speed level shifters to try to interface with ESP32, but based on the reference circuit, nothing else besides some decoupling caps and a pullup resistor would be needed
• Battery voltage is 2.9V min, 3.7V typical, and 4.8V max, so theoretically possible to share a 3.3V supply with the MCU, but would NOT be ok with 5V supply
• "Driver IC RAM Size" is specified as "Full RAM or 1/2 RAM" which seems to indicate that the RM69330 has a framebuffer which makes the idea of driving it with an ESP32 seem more plausible

Still seems like an uphill battle to get this working without additional documentation, but I will try to keep making progress. If the connector I ordered works, my next step will probably be to spin a quick breakout PCB for the connector and level shifters based on the pinout in the spec sheet I found... If the connector doesn't work it's back to scouring the internet for more clues...

[olibali]

Hello!

I am in the process of making a CircuitPython driver for an OLED display called: "PV13904PY24G".
It also uses RM69330 as driver chip. I only use the SPI interface.

It is not yet done but I need to step away from it and maybe someone can continue or learn from what i already have.

[hareshPrajapati]

Can you please send a copy of original datasheet or authenticate source of RM69330 driver initialization process source and other sequences of AMOLED graphics codes.

[olibali]

Sure.

What I ended up doing is using the 'displayio' of the Circuitpython framework.
Using that is super easy and you just need to provide some details like this:

Code: [Select]

def display_init():
displayio.release_displays()

vciEn = DigitalInOut(board.IO14)
vciEn.direction = Direction.OUTPUT
vciEn.value = True # turn on dc-dc converter(s)?!

xres = DigitalInOut(board.IO12)
xres.direction = Direction.OUTPUT
xres.value = False # keep device in reset mode

xres.value = True
time.sleep(0.02) # 10ms
xres.value = False
time.sleep(0.02) # 20ms
xres.value = True
time.sleep(0.15) # 150ms

spi = busio.SPI(clock=board.SCK, MISO=board.MISO, MOSI=board.MOSI)

while not spi.try_lock():
pass

spi.configure(baudrate=1000000, phase=0, polarity=0)
spi.unlock()

display_bus = displayio.FourWire(
spi, command=board.IO5, chip_select=board.IO6 #, reset=board.IO12
)

init_sequence = (
b"\xFE\x00" # set command page: "User Command Set", 0 parameters
b"\x35\x01\x00" # tearing on: "vertical blanking only"
b"\xC4\x01\x80" # set SPI wram, required for SPI interface init
b"\x3A\x01\x05" # set 8 bit pixel format; 2 -> 8 bit
b"\x11\x80\x78" # sleep out then delay 0x78 (120ms)
b"\x29\x80\x78" # set display on then delay 0x32 (120ms)
)

display = displayio.Display(display_bus, init_sequence, width=454, height=454, color_depth=16,
set_column_command=0x2A,
set_row_command=0x2B,
write_ram_command=0x2C,
brightness_command=0x51, brightness=0x80
)

display.auto_refresh = False
# display.brightness=0.5

return display

Then you can use the displayio's 'group', 'bitmap', 'text' features.

[olibali]

Datasheet of the RM69330 graphics display driver i have on my hands.

[peter-h]

Some pointers here
https://www.eevblog.com/forum/projects/small-tft-display-5x5cm-for-moving-graphics-over-spi/msg3977906/#msg3977906

[hareshPrajapati]

I want to develop display driver using c/c++ and I think I close to the development process but there is confusion regarding display connections you mention above
 I mean if you provide some of pinout or schematics than it will help me a lot. 

[olibali]

Others have asked me if I have further details, working code etc. Unfortunately I dropped the project because soldering that tiny connector to a PCB is hard for me. Few pins of the connector always broke off and the connector had intermittent issues. Sometimes working sometimes not working. I might get back to it in the future and solve this soldering issue.

Until then here is what I have.
amoled.py and gfx.py. Both are early tries based on the PDF documentation. Directly using the SPI interface, no library. They are not complete. They did something as far as I remember. But using the displayio library is far-far easier and I would recommend doing that.

Also check out this: https://github.com/cateajansmedya/android_kernel_mediatek_mt6739/commit/adb0fda4687ce4d4ec1a4ecfab771d79f623a6b1
Here you can see some RM69330 related code. It uses DSI and not SPI but the commands are similar, you could use the sleep_in, sleep_out, ambient_in, ambient_out, suspend, resume parts of the code. The bytes to send should be the same for SPI.

I can also share my PCB (eagle cad breakout board attached). Maybe it helps somepony.
As for the schematic I used a TXB0108 logic level shifter because my microcontrolled has 3.3V IO pins and I had to step them down to 1.8V for the OLED.

So basically:

Controller pin	Oled pin	Extra info
-	VBAT	Connected to 4.2 volts (real lipo battery)
SPI MISO (3.3V)	SPI_SDO(1.8V)	Connected through logic level shifter (serial data from oled to mcu)
SPI MOSI (3.3V)	SPI_SDI(1.8V)	Connected through logic level shifter (serial data from mcu to oled)
IO5 (3.3V)	SPI_DCX(1.8V)	Connected through logic level shifter (data or command selector)
SPI SCL (3.3V)	SPI_SCL(1.8V)	Connected through logic level shifter (clock)
IO6 (3.3V)	SPI_CSX(1.8V)	Connected through logic level shifter (chip select, active low)
IO12 (3.3V)	XRES(1.8V)	Connected through logic level shifter (oled reset, active low)
	VDDIO	1.8V
GND	GND	Common ground
IO14	VCI_EN (1.8V)	Connected through logic level shifter (oled power enable? maybe controls some charge pump power ICs onboard?)

The rest of the pins I did not connect.

All of the pins are 3.3V MCU -> 1.8V OLED except the SPI_SDO which is the opposite, 1.8V OLED -> 3.3V MCU.

One important piece of information!: The Logic level shifter I used does not support 1.8V on both A and B sides. Be careful which side is 1.8V capable. If you connect it backward it won't work and might damage the OLED? Maybe..