Controlling controller-less GLCD

I had one of these CLGLCDs for some time, salvaged some time ago from retired tape library. The controller module was not salvaged, but looking at images (search for 263645-001), looks like it was driven with FPGA and unlikely it can be repurposed. General sentiment about these modules seems to be that it would be hard to do it with Arduino and you need something specialized like SEDxxxxx controller, which are difficult to find or come in tiny breadboard un-friendly packages. Also, The number of pins you will need to control the controller might be higher than what you need for the bare LCD module.

Something similar has been done:

• ATmega8515,
• another with ATmega8515
• PIC
• ESP32

On the other hand, people have driven VGA monitor with 8-bit AVR...

So here is my hack of the module, driven by different small Arduinos. Code and more detailed description is available at GitHub

Static image

Among the first thing I tried was to display image stored in flash. I used 3x 9V batteries for negative voltage and trimmer as V0 voltage divider. The first successful attempt was this:

I still do not remember how I managed to flip the image on this one (see where the flat cable is?). Anyway, there is 'simple' example in the GitHub repo...

Text mode

Changing the data at runtime was more chalenging. For start, we don't have 9600 bytes of memory on AVR Arduinos, at least not to drive this thing in graphic mode. Below is my hack for driving this display in text mode, with font stored in flash and text screen buffer in SRAM.

The short version: You need assembler to this on AVR: 

...
lpm r24, Z  
;----------            (CL2 rising edge)
out %[data_port], r24
ld r30, X+
swap r24;              (CL2 rising edge)
out %[data_port], r24
lpm r24, Z
;----------            (CL2 rising edge)
out %[data_port], r24
...

 Again, there are more technical details on GitHub.

Required hardware

For my module (F-51543NFU-LW-ADN / PWB51543C-2-V0) I used:

• 16MHz AVR Arduino
  • Tested with UNO, Leonardo and ProMicro clone.
• Negative voltage for LCD drive 
  • For simplicity, I used an A0524S-1W unregulated isolated DC-DC converter, but anything like MC34063 or MAX749 can be used,
  • No special regulation is needed, module is surprisingly tolerant. 
  • approx. -24V, <6mA (absolute max is -30V to GND, or Vdd-Vee < 35V) 

• 2x N-Channel logic-level MOSFETs
  • IRL530n, control for backlight and negative voltage generator (overkill, but I had those in hand)

• Passive components
  • Trimmer for V0 voltage divider,
  • R1+R2 ~= 250Kohm, V0 voltage should be -16.8V at 25C (from datasheet)
  • Few pull-down resistors (i.e. 10Kohm)

• Breadboard and jumper cables.

So, what can you do with this relic? Maybe a QR clock?

Cat aside, you can try to program your favorite serial LCD emulation in the main loop "user" space...

Soft fonts

Another nice feature would be to have some amount of character data in memory instead all of it in flash, thus being able to change characters on the fly and/or draw smaller graphics on part of the screen.


Below is small demo/example with soft fonts, 64 characters as 128x64 graphics:

Code and explanation are on GitHub. Note that using soft characters, in addition of eating SRAM, slows down main loop significantly. It is a trade-off, but if main purpose of the Arduino is driving the display, it maght be useful.


Graphics mode and grayscale

Arduinos based on 8-bit AVR (even Megas) don't have SRAM to hold the whole 320x240 screen buffer, period. And grayscale image would need more. Using external SRAM might be possible (i.e. 23LC512 in SQI mode could possibly be used as kind-of DMA engine, pumping the data directly to the display while you just PWM the clock), but then it gets complicated how and when you can change the data in the external SRAM and it is questionable if this would be cost efficient compared to i.e. ESP32 which can send the data via proper DMA and has plenty of SRAM).

Please check the project log for updates...


If you just to wanted...