Nokia N85 / N86 AMOLED interfacing (& surprise) …

Have a look at it :

Notice that it is an AMDN001 marked module (which is, in fact, real AMOLED from N85/86).

Now the surprise : it works with the command set known from E51/6500c LCDs…
Yes! No changes, just solder the wires, build +5V/-5V DC-DC converter & Voilla…

The DC-DC can looks like : (I’ve managed to homemade it on 2.5×3.0cm single sided PCB).
n86_tps65136_sch

TPS65136 is available in QFN package only, its tricky to solder it at home, but having any hot-air & flux should do the trick. Remember that thermal pad should be GND-ed (& soldered too, of course).

UPDATE #1: There is one error in schematic – the L1 inductor should be 2.2uH or 4.7uH instead of 10mH (ekhm… “hardly available” 🙂 ).
To successfully drive this AMOLED it is sufficient to have such wiring : D0-D7, RES, WR, DC for control, and power sources : 3V3, ELVDD, ELVSS.
There is no need for 1V8 and level shifters like LVC4245. Driving VIO pin (12) with 3.3V voltage we’re getting whole interface bus working at 3.3V. (Don’t know exact timing impact with such voltage change, but it works at full speed achievable with PIC32MX parallel master port)

Nokia Display Modules Hacking Platform :)

NDMHP in short 🙂 easy, huh ?

Today, I’ve got some hardware & software to share – In the meantime I’ve created some nice piece of hardware, and I named it as you can see above.
It consists of :
1). PIC32MX340F512H prototype board (PIC & necessary components to run it)
2). Voltage-level shifter based on LVC4245
3). Adapter board with voltage inverter & stabilizer (~+5V/-5V for amoled display) – not recommended to use, try to get TPS65136 (www.ti.com/product/tps65136) instead.
4). Power source with different voltages (1.8V, 2.5V, 3.3V, 5.0V, 12.0V)

Here comes some pictures of this crap :

Fig.1. PIC32MX proto-board

Fig.2. Level-shifter & n86 adapter board with DC-DC inverter & stabilizer

Fig.3. Photo of working AMDF001 connected to that crap above.

Here comes some schematics :
1) I would not provide you with proto-board of PIC32MX, because it is so self understandable, that it would be a shame to do this…
2) Level-shifter & n86 adapter board :
level_shifter_sch
n86_oled_adapter_sch

And some code, (very dirty but working…) :
https://rapidshare.com/files/2973078098/hack_n86_amoled.zip

Some description :
PC is connected to PIC32 via RS232 @ 57600 bauds (MAX3232 not visible – mounted inside COM1 plug, powered from PIC32 proto-board). PC is running C# program – win_amo_hack, PIC32 is flashed with included code (n86_amoled_hack).
Communication protocol PCPIC is described below :
– commands are sent as text strings
– commands :
a) ‘r’ – reset (assert RESX line low for 5ms & release high)
b) ‘C’ – pull chip select low (CSX=LOW)
c) ‘c’ – release chip select high (CSX=HIGH)
d) ‘i[xx]’ – write index register/execute command simple command (DCX=LOW, perform write of hexadecimal number [xx] via ParallelMasterPort, eg. “i29” – send DISP_ON command on MP1.0 protocol
e) ‘d[xx]’ – write single byte of data (DCX=HIGH, perform write of hex [xx] via PMP, eg. “d00” – send 0x00 to LCD)
f) ‘t’ – return tearing line status (returns t00 or t01 according to TE line level)
g) ‘g’ – read register or data (DCX=HIGH & perform read via PMP)

Examples:
“i01i11i29” – this string will initialize MP1.0 display (reset, sleep-out, display-on)
“i2cd00d11d22” – this string will send one pixel data (0x2c – GRAM_WRITE), color 0x001122

Win_amo_hack has also ability of execution of Lua scripts.
It defines two functions : amoSend & amoTear. First one takes single string argument & sends that string to PIC32. Second one returns TE line status as a byte.

Sample Lua script :
amoSend("Ci2ad00d00d00defc")
amoSend("Ci2bd00d00d01d3fc")

amoSend("Ci2c")
for y=0,319 do
for x=0,239 do
amoSend(string.format("d%02xd%02xd%02xd%02xd%02xd%02xd%02xd%02xd%02xd%02xd%02xd%02x",x,x,x,x,x,x,x,x,x,x,x,x))
end
end

Well, that’s basically it.
This platform is quite powerfull and can be used to hack multiple types of LCDs, as long as LCD is interfacing via Intel-80 parallel bus.

Have fun.

Nokia N85/N86 AMOLED display hacking project AMDF001 / AMDN001

Well, after a while , I’ve found that E51-like LCD displays are barely readable in sunlight, which renders them unusable in outdoor conditions. So, after deep search, I’ve found nice and cheap potential solution : N85/N86 display.
It is active matrix OLED screen (AMOLED) 320×240, 2.58″, manufactured by (I believe) Samsung SMD (www.samsungsmd.com). There is markup on this OLED : AMDF001 AMDN001 (see below …) (which is probably FPCB model type (flexible printed circuit)). Other ID’s are : 4850084 (which is probably manufacturer ID code (see google)), MP1.0 which denotes interface protocol? (MeSSI ?)

Display have FPC 24-pin connector widely used by Nokia (same as E51), but different pinout is used – see N85/N86 schematic wiring diagram -> google it, download level 1/2 manuals.

Nokia uses codename Falcon for this display -> no effect after google.

What I’ve done :
1. As microcontroller I used PIC32MX (340F512H), communicating with PC via UART
2. I’ve created 2 prototype boards :
a) level shifter board (3.3V -> 1.8V) using 74LVC4245A (2x) one for databus D0..7, one for controls (RDX,WRX,RESX,DCX)
b) OLED display power supply (MC1727-500 & MAX889) generating -4.9V & +4.6V for ELVSS & ELVDD respectively.
3. I’ve dismounted 24 pin connector from display’s FPCB and soldered 24 wires to that connector’s pads (I’ve used old 80-pin ATA cable as a small wire donor)

After battle with my solder gun I finally ended up with working prototype, with NULL knowledge of protocol…

Digging the Web for similar display’s datasheets I’ve found that similar displays controllers using similar interface protocols, of course AMDF001 is using Intel 80 8-bit bus, just like E51 module.
It seems that it is using such protocol :

1. with DCX=0 write register addr (D0..7 => reg index)
2. with DCX=1 write data to that register … 8-bit or 16-bit??? (double 8bit transfers?)

After brute-forcing this module I’ve found that it is responding to commands (screen blinks, fades in/out, eventually even GRAM memory contents showed up on screen, nice)

Now it is long road to descramble the protocol & register locations…

Or maybe someone has something to say in this topic ???
Any help appreciated!

Update #1 : After days of digging the net searching for possible driver IC that drives this amoled, I’ve found that:
1) probably I have problem with connection bus (amoled seems to respond randomly to sent commands)
2) amoled is responding only when (sic!) LVC4245 is driven reversed (pic<-amoled) on data bus… strange..
3) I personnaly think that IC might be LD9014 from LDT,inc.
4) I really don't think it is S6E63D6X, just because of 262K color depth instead of proclaimed 16.7M for this amoled

Update #2 : Shame on me! These modules I got aren’t AMOLEDs… They turn out to be cheap chinese fakes – LCDs, looking like AMOLED, but they’re not.
Waiting for new delivery, hoping for getting real AMOLED now for n85/86.
Bloody differences ? Here you’ve got :
1) Shorted pins 11 & 12 (EL_ON VIO), gives constant 1.8V on EL_ON…
2) There is small BGA packaged IC on the FPCB just below the screen ( on the back side) – it is probably dc-dc charge pump for LED backlight (very smartly hid below the screen), original AMOLED has only some discrete smd parts on FPCB…
3) real AMOLED has MP2.1 protocol designation & AMS258DN01 module type (driver IC still unknown)

Update #3 : Module marked AMDF001A is an ordinary TFT module compatible with MP1.0 protocol, just like E51 module. Only pinout & backlight driving are different.
Still waiting for AMDN001 modules (which should be amoleds)

Debugging PIC32 application user interface code

Consider this situation : you’ve connected LCD to your PIC, everything is running smooth, putpixel, fills, clrscr, etc…
Now you’d like to draw some UI elements like labels, texts, buttons, gauges, grids, etc…
One can tell – use Microchip’s GOL Library. Ok – it’s easy, when GOL supports your LCD controller. It’s more complicated when you need to write GOL custom driver to your LCD. That’s the first way.

You can always write your own code, providing you a full set of GUI objects, but there comes a problem : how to debug it easily, without thousands of programming your poor PIC and lazy, terribly slow debugging with tools like ICD-2,etc…

Solution is pretty easy – do it on your well known x86 platform 🙂
For example, install DevC++, install Allegro DevPak, use allegro template to create main.c, add your PIC GUI files to project, use #ifdef __PIC or #ifdef __PIC32MX to exclude PIC specific code and provide LCD driver layer that works with Screen bitmap from allegro. Fast, convenient way. When your library will be bug-free, it will be ready to compile in MPLAB C Compiler…

Initialization of MeSSI LCD…

Today, i’ve found that not only proper RESET signal timing is required to initialize such LCD properly, but also there should be correct driving of power lines to LCD (+1.8V, +2.5V).
Your design should include power switches, driven by your MCU to achieve control over power sequence of LCD.

I’ll investigate it and share my findings soon…

Update #1 : I’m not so sure about this now…
Update #2 : I’m almost sure that it doesn’t matter at all 🙂

Time to post some details

Here you have interface schematic & pcb i’m using to prototyping :

Schematic:
sch_e51
PCB:
pcb_e51_lcd2

Schematic is totally based on BikeRk6’s one, posted here : http://www.elektroda.pl/rtvforum/topic1344700.html

PIC32 Code – Nokia E51 Library:
LCD_E51.ZIP
PIC32 Code – test workspace
test_e51lcd.zip’

Consider this code as pre-alpha release 🙂 It’s dirty, it’s uncommented. It works only partially -> depending on your LCD… You may find it similar to Microchip’s graphics library… it isn’t totally unintended 🙂

Have fun, feel free to improve it!

Controller type consideration about LCDs

E51?: LCD ACX559AKM-7 (SONY?)- code 4851025 : controller compatible partially with LDS285 (but probably it is not LDS285)
6500c: LCD LS8303164 (SHARP) code 4850198 : more compatible with LDS285 (responding to DISCLK command properly)
E65: LCD LS022Q8UX04 (SHARP) : partial compatibility with LDS285

No one of them have built-in LED driver (no one responded to LEDCTRL command of LDS285)…

UPDATE:
It seems that these LCDs are compatible to this controller : http://hw.cz/files/redaktor130/MC2PA8201pdf.pdf

Using Tearing Line Output from Nokia LCD

Nokia LCDs mentioned in this blog has tearing line output feature. It can be used to synchronize MCU->LCD writes with LCD display memory scan pointer.
What for? To prevent showing partially content we want to write to LCD’s display RAM.

Problems :
A) your MCU should be fast enough to stream whole framebuffer to LCD within TE (Tearing Effect line output) pulse -> then, LCD read pointer won’t start scanning the frame before whole MCU->LCD transfer ends.
OR:
B) your MCU should be fast enough to stream whole framebuffer to LCD between n and n+2 TE pulses -> then LCD read pointer starts before write to LCD display memory occurs and write pointer will be always behind read pointer of LCD’s memory controller.

If your MCU isn’t fast enough to meet these requirements, tearing would always appear…

TE pulse width is given by LCD’s frame refresh rate (default ~60Hz).
At 60Hz frame scan time is about 16ms. Full frame is 320x240x3 bytes = 230400 bytes. To be able to write full framebuffer during two frame scan time (option B) your MCU should have data computation & throughput speed ~7 MB/s…
Well, it is impressive in the world of cheap and easy MCUs, even PIC32s 🙂