The basic 16×2 LCD is an extremely popular component that we’ve seen used in more projects than we could possibly count. Part of that is because modern microcontrollers make it so easy to work with; if you’ve got an I2C variant of the display, it only takes four wires to drive it. That puts printing a line of text on one of these LCDs a step or two above blinking an LED on a digital pin on the hierarchy of beginner’s electronics projects.
The basic idea is to “blink” the 5 V line so quick that a capacitor on the LCD side can float the electronics over the dips in voltage. As long as one of the pins of the microcontroller is connected to the 5 V line before the capacitor, it will be able to pick up when the line goes low. With a high enough data rate and a large enough capacitor as a buffer, you’re well on the way to encoding your data to be displayed.
For the transmitting side, [Vinod] is using a Python script on his computer that’s sending out the text for the LCD over a standard USB to UART converter. That’s fed into a small circuit put together on a scrap of perfboard that triggers a MOSFET off of the UART TX line.
If you’re reading this article on a desktop or laptop computer, you’re probably staring at millions of pixels on a TFT LCD display. TFT became a dominant technology due to its picture quality and fast response times, but it’s not the only way to build an LCD. There are cheaper technologies, such as STN and its color variant, CSTN. They’re rarely used nowadays, but [Wenting Zhang] had one lying around and wanted to take a crack at driving it.
The screen in question came courtesy of a 20th century laptop. It’s a Hitachi SX21V001-Z4, with a resolution of 640×480 pixels. Driver boards for CSTN screens were once readily available, however now such things are difficult to come by.
[Wenting] instead grabbed an FPGA and got to work. Driving displays can be taxing for small microcontrollers, so an FPGA is always a great choice when working on such projects. They’re easily capable of generating whatever weird and wacky signals are required, and can generate many such signals in parallel without breaking a sweat.
[Wenting] successfully got the screen up and running, and hooked up to a VGA input. Image quality is surprisingly passable for still images, though things absolutely go to pieces when motion is introduced. [Wenting]’s demo shows off the screen playing Breath of the Wild, and it’s a great showcase of how far technology has come since the mid-90s.
Driving strange LCDs is a hacker rite of passage, and we see plenty of efforts around these parts. Video after the break.
These days, you could be forgiven for thinking driving an LCD from a microcontroller is easy. Cheap displays have proliferated, ready to go on breakout boards with controllers already baked in. Load up the right libraries and you’re up and running in a matter of minutes. However, turn your attention to trying to drive a random LCD you’ve yanked out of a piece of old equipment, and suddenly things get harder. [Ivan Kostoski] was in just such a position and decided to get down to work.
[Ivan]’s LCD was a 320×240 STN device salvaged from an old tape library. The display featured no onboard controller, and the original driver wasn’t easily repurposed. Instead, [Ivan] decided to drive it directly from an Arduino Uno.
This is easier said than done. There are stringent timing requirements that push the limits of the 8-bit platform, let alone the need for a negative voltage to drive the screen and further hardware to drive the backlight. These are all tackled in turn, with [Ivan] sharing his tips to get the most flexibility out of the display. Graphics and text modes are discussed, along with optimizations that could be possible through the varied use of available RAM and flash.
The LCD in question is a 240×160 monochrome device, that was initially being driven successfully with a Microchip PIC24 with a dedicated LCD driver peripheral. This allowed [pataga] to study the display interface under working conditions with the help of an oscilloscope. Inspiration was then taken from a project by [Sprite_tm], which used the I2S peripheral to drive a small LED display without placing load on the CPU.
Using the ESP32’s I2S peripheral in parallel mode makes it possible to shift data out in the correct format to drive the LCD without bit-banging IO pins and using up precious CPU time. This leaves processor cycles free to do interesting things, like generating 3D images using [cnlohr]’s routines from the Channel 3 project. There’s a little extra work to be done, with the frame signal being generated by an external flip flop and some fudging with the arrangement of various registers, but it’s a remarkably tidy repurposing of the I2S hardware, which seems to be the gift that keeps on giving. (Here it is spitting out VGA video through a resistor DAC.)
Code is available on Github for those looking to get at the nuts and bolts of the hack. It’s another build that goes to show, it’s not the parts in your junk box that count, but how you use them.
Nintendo’s Game Boy was the handheld of the 1990s. Like many of their products, it was famous for its ability to stand up to punishment from angry children and military strikes alike. Its biggest weakness is perhaps its unbacklit LCD screen. Retrogamers and chiptuners alike find themselves modifying and replacing these regularly.
A common problem during these swaps is “Newton rings” – an issue where the polarizer comes into contact with the LCD glass, causing unsightly visual artifacts. Thankfully, there is a simple fix. It’s possible to keep the two separated with the application of microscopic particles, too small to see. [esotericsean] uses cornstarch, while [bogamanz] favors diatomaceous earth. For best results, a makeup brush can be used to apply a fine coating, and compressed air used to clean out the Game Boy and remove any excess.
It’s rare to fix a delicate screen problem with a household staple, but gratifying when it works. The results are hard to see on camera, but many report this fixing the frustrating issue. So, if you’re planning to backlight your Game Boy, keep this in your bag of tricks. It’ll allow you to get the best possible result, and may be useful on other old-school LCDs as well. Video after the break.
China, we’re told, can make anything. If you need some PCBs in a few weeks, there are a few factories in China that will do it. If you need a nuclear reactor, yep, there’s probably a factory in China that’ll do it because nuclear reactors are listed as one of the items facing new tariffs when imported into the United States. No, I am not kidding. What about LCDs? What about old-school character LCDs? Is it possible to find a factory in China that will make you the LCD you want? That’s what [Robert Baruch] will find out, because he’s repairing an old computer with new parts.
The object of this repair and restomod is a TRS-80 Pocket Computer (PC-1), otherwise known as the Sharp PC-1211. It looks like a calculator, but no, it’s a legitimate computer you can program in BASIC. [Robert] bought this computer for a bit more than $5 on eBay ‘for repair’, which means the zinc-air battery was dead, and unfortunately, the LCD was shot. The LCD technically works, but it just doesn’t look good. Sometime in the last thirty years, moisture got in between the layers of glass, polarizing film, and liquid crystal. This is not unique to [Robert]’s unit — a lot of these PC-1s have the same problem, many of these broken seals rendering the computers themselves useless.
This is an ancient computer, and replacements for this LCD are impossible to find, but because the Sharp PC-1211 is well documented, it is possible to find the datasheet for the original display. With that, it’s just a question of finding an LCD manufacturer that will do it. So far, the costs look good — $800 USD ($300 for tooling and 10 samples, $500 for another 200 LCDs) is what it’ll take to get a few units. [Robert] already has a few people interested in repairing their own Pocket Computers. You can follow the eevblog thread here, or check out the video below.
Hackers really like their tools. This leads to holy wars over languages, editors, keyboards, and even laptops. The problem with laptops is that they age, and not always gracefully. [Syonyk] likes his ThinkPad T430S, except for one thing, its TN display wasn’t really very good. These flat screens use an older technology and show color changes with different viewing angles among other problems. So he managed to upgrade the device’s screen to IPS with the help of a replacement screen and an adapter (see right). Apparently, many similar ThinkPads can take the same sort of upgrade.
The problem is that the laptop uses LVDS to talk to the TN screen, while newer screens are likely to use Embedded DisplayPort (eDP) which is a different protocol entirely. However, there’s now a converter that [Syonyk] found on eBay (from China, of course). For about $70, the motherboard’s LVDS output can transform to eDP. Of course, you also need an IPS display panel.