Picture of completed LCD case with test circuitry partially connected. The LCD’s backlight is powered, but not the rest of the LCD’s circuitry, so it just shows a white rectangle.

The inner shell and spacers are made from the 0.5 mm cardstock. The LCD is sandwiched between the front and back shell pieces, with a cutout for the image area of the LCD in the front, and a cutout for some circuitry on the flat-flex in the back. The black bars are cutouts for the spacers, which hold the LCD in place. The back shell has an additional slit for the flat-flex connector to go through. The tabs on the spacers go through the slits, and then get folded and taped down.

Artwork is rasterized at 150 DPI with transparency enabled, so if you can’t see anything, it’s because you’re seeing black lines on a dark background. The thick bars are cutouts and should be exactly 0.5 × 10 mm. Yes, that’s Dots Per Inch with metric measurements. Such is engineering in the US.

The outer shell, also made of 0.5 mm cardstock, folds around the inner shell, again with cutouts for the LCD image and the flat-flex connector. It is also taped in place. I tried to leave enough extra padding in the template so that, when folded, it wouldn’t be too snug, but it turned out to be a bit too snug anyway. The outer shell has tabs that insert into the trapezoidal side panels.

The side panels are made of 2.2 mm cardboard. The additional stiffness supports the LCD because I’m not sure the cardstock would be stiff enough. A rectangular back piece, also of cardboard, acts a strut to keep the back side of the trapezoid aligned.

For the shell and spacers, I only taped template paper to one side because the cardstock is thin. However, because the cardboard is much thicker, I printed mirror images of the trapezoidal side panels (and back panel), and taped them to both sides of the cardboard. This is especially useful for the small slits, which need to be cut out with fairly good alignment.

Finally, to interface with the LCD, I have a 50-pin ZIF connector breakout. It is mounted to another copy of the back panel, but positioned next to the LCD. The purpose of mounting the breakout (and indeed, of having a case at all) is to prevent strain on the LCD’s flat-flex connector.

There are datasheets available for modules with similar part numbers. Based on the circuitry in the above picture, this looks like the closest pinout:

B&W LCD modules usually have a built-in charge pump to generate their needed voltages. Unfortunately, the datasheet also says this module needs those voltages supplied externally, and they’re a bit weird.

VDH: +8.3–+8.7 V @ 3.3 mA

VGH: +16.2–+17.0 V @ 0.23 mA

VGL: −8.35–−8.0 V @ 0.17 mA

VCC: +2.5–+3.3 V @ 0.22 mA (this is actually a normal voltage)

Fortunately, I don’t have to design and build a boost circuit myself; you can Just Buy voltage boost modules easily from many places. Getting a module to generate that negative voltage, however, is a lot harder. But it turns out that charge pump chips are A Thing you can Just Buy on Digikey. Sadly, charge pump chips tend to have fairly low output current capability, so while charge pumps could produce the high voltage for the backlight, it would require several and be kind of awkward.

So last week and this week, I finally sat down and learned enough about PIO on the Pi Pico to produce suitable timing signals for the module.

The first LCD I got working was this 96×65 LCD from a Nokia 6340I. It’s the highest-resolution B&W panel I have. It appears to have a refresh rate of around 80 Hz, which is good for grayscale. Unfortunately, it also does not appear to have dual-ported GRAM, meaning that if you try to write to a pixel at the same time the driver is reading it during its refresh cycle, the read will be corrupted. This shows up on this display as a streak of black pixels.

The line moves over time because it depends on the precise microsecond-level timing between when LCD COG updates the pixels and when the microcontroller sends new pixels. Sometimes it goes off-screen entirely, and when the line isn't visible, the grayscale does look good. Unfortunately, there is no Vsync signal available to help synchronize writes to when the line would be off-screen.

On the other hand, this 96×32 module from a flip-phone does appear to have dual-ported GRAM. Not only that, but the driver appears to be a 96×64 matrix driver, meaning it has twice as much GRAM as it actually needs. Most drivers have a “scrolling” feature that lets you change which line of GRAM appears at the top of the screen. This means that whether or not it’s dual ported, you can send pixel data to the non-visible GRAM, and then instantaneously switch to the new frame.

The grayscale code tries to reduce how distracting the flicker is by applying a noise pattern, so that, instead of all pixels of a given gray level flipping at the same time, they flip at different times. This changes the flicker into more of a shimmer effect. Unfortunately, this LCD has both more responsive pixels and a slower refresh rate of about 40 Hz (which I can’t change), and I don’t think any algorithm can overcome those limitations.