Hackers have a multitude of skills, many are well-versed in the ways of all things that blink and flash. These abilities have often be applied to the field of jewelry and human adornment, and many LEDs have been employed in this work. [Deshipu] has been attempting something a touch different however, by constructing a tiny TFT pendant.
The basic idea is not dissimilar from those USB photo keychains of recent history. A SAMD21 Cortex M0+ serves as the brains of the operation, with the tiny microcontroller being soldered to a custom PCB that makes up the body of the pendant. A ST7735S TFT LCD screen is then attached to act as the display. Charging and delivery of images is done over USB, which can be handled natively by the SAMD21.
Currently, the pendant is capable of displaying 16-color BMPs, with the intention to create a converter for animated GIFs in the pipeline. Potential upgrades also involve creating a larger battery pack to sit behind the wearer’s neck, as currently the device has just 8 mAh to work with.
(Pedantic Editor’s Note: VFDs actually run a little warm.)
At least that’s the reasoning [Scott M. Baker] applied to his Prusa upgrade. We have to admit to a certain affection for all retro displays relying on the excitation of gasses. Nixies, Numitrons, and even the lowly neon pilot light all have a certain charm of their own, but by our reckoning the VFD leads the pack. [Scott] chose a high-quality Noritake 4×20 alphanumeric display module for his upgrade, thriftily watching eBay for bargains rather than buying from the big distributors. The module has a pinout that’s compatible with the OEM LCD, so replacing it is a snap. [Scott] simplified that further by buying a replacement Prusa control board with no display, to which he soldered the Noritake module. Back inside the bezel, the VFD is bright and crisp. We like the blue-green digits against the Prusa red-orange, but [Scott] has an orange filter on order for the VFD to make everything monochromatic. That’ll be a nice look too.
A completely none functional hack, to be sure, but sometimes aesthetics need attention too. And it’s possible that a display switch would help the colorblind use the UI better, like this oscilloscope mod aims to do.
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.