Photo of the spectrophotometer in question, with a screenshot of the decoding software on the right

Exporting Data From Old Gear Through LCD Sniffing

May 5, 2022 by 27 Comments

[Jure Spiler] was at a flea market and got himself a spectrophotometer — a device that measures absorbance and transmittance of light at different wavelengths. This particular model seems to be about 25 years old, and it’s controlled by a built-in keyboard and uses a graphical LCD to display collected data. That might have been acceptable when it was made, but it wasn’t enough for [Jure]. Since he wanted to plot the spectrophotometry data and be able to save it into a CSV file, hacking ensued.

He decided to tap into the the display communication lines. This 128×64 graphical display, PC-1206B, uses a 8-bit interface, so with a 16-channel logic analyzer, he could see the data being sent to the display. He even wrote decoder software – taking CSV files from the logic analyzer and using primitive optical recognition on the decoded pixels to determine the digits being shown, and drawing a nice wavelength to absorbance graph. From there, he set out to make a standalone device sniffing the data bus and creating a stream of data he could send to a computer for storage and processing.

[Jure] stumbled into a roadblock, however, when he tried to use an Arduino for this task. Even using a sped-up GPIO library (as opposed to notoriously inefficient digitalRead), he couldn’t get a readout frequency higher than 80 KHz – with the required IO readout rate deemed as 1 MHz, something else would be called for. We do wonder if something like RP2040 with its PIO machinery would be better for making such captures.

At that point, however, he found out that there’s undocumented serial output on one of the pins of the spectrophotometer’s expansion port, and is currently investigating that, having shelved the LCD sniffing direction. Nevertheless, this serves as yet another example for us, for those times when an LCD connection is all that we can make use of.

We’ve seen hackers sniff LCD interfaces to get data from reflow ovens, take screenshots from Game Boys and even equip them with HDMI and VGA ports afterwards. With a skill like this, you can even give a new life to a vintage calculator with a decayed display! Got an LCD-equipped device but unsure about which specific controller it uses? We’ve talked about that!

Continue reading “Exporting Data From Old Gear Through LCD Sniffing” →

Retro Serial Terminal Uses Modern Chips To Get CP/M Machine Talking

March 6, 2022 by 26 Comments

The hobbyists of the early days of the home computer era worked wonders with the comparatively primitive chips of the day, and what couldn’t be accomplished with a Z80 or a 6502 was often relegated to complex designs based on logic chips and discrete components. One wonders what these hackers could have accomplished with the modern components we take for granted.

Perhaps it would be something like this minimal serial terminal for the current crop of homebrew retrocomputers. The board is by [Augusto Baffa] and is used in his Baffa-2 homebrew microcomputer, an RC2014-esque Z80 machine that runs CP/M. This terminal board is one of many peripheral boards that plug into the Baffa-2’s backplane, but it’s one of the few that seems to have taken the shortcut of using modern microcontrollers to get its job done. The board sports a pair of ATmega328s; one handles serial communication with the Baffa-2 backplane, while the other takes care of running the VGA interface. The card also has a PS/2 keyboard interface, and supports VT-100 ANSI escapes. The video below shows it in action with a 17″ LCD monitor in the old 4:3 aspect ratio.

We like the way this terminal card gets the job done simply and easily, and we really like the look of the Baffa-2 itself. We also spied an IMSAI 8080 and an Altair 8800 in the background of the video. We’d love to know more about those.

Continue reading “Retro Serial Terminal Uses Modern Chips To Get CP/M Machine Talking” →

Raspberry Pi Takes Over Volvo’s Integrated LCD

February 5, 2021 by 11 Comments

As [Luuk Esselbrugge] explains in a recent blog post, his 2002 Volvo S60 had an optional GPS navigation system and backup camera that used a motorized display that would rise out of the dashboard when needed. His particular car didn’t come with the hardware installed, but after getting his hands on a display module and doing some research, he figured out how he could drive it with the Raspberry Pi and a couple of microcontrollers.

Given the age of the display, you probably won’t be surprised to hear that it uses composite video. Not exactly high resolution, but in the demonstration after the break, we have to admit it looks more than up to the task. [Luuk] is running Android Auto on the Raspberry Pi 3 through the openauto project, which gives him a nice big display and access to all the navigation and media applications you’d expect. The display doesn’t support touch, but thanks to an ESP32 plugged into the CAN bus, he’s able to control the software by reading the buttons built into the Volvo’s steering wheel.

Composite video sources are switched with a simple relay.

To actually raise and lower the display, [Luuk] found you just need to fire a few bytes down the 1,200 baud serial bus that’s built into the display’s wiring harness. The ESP32 handles this duty as well, at least partly because it’s already plugged into the CAN bus and can tell when the vehicle is in reverse. This lets it bring up the screen to show the video feed from the newly installed backup camera in the event that the Pi hadn’t already asked to raise the display. Incidentally plugging in the phone normally triggers the system to wake up and raise the screen, and disconnecting it will command the screen to lower back into the stowed position.

The attentive reader or Volvo aficionado may be wondering how [Luuk] got the audio working. Since his car’s sound system doesn’t feature an auxiliary input, he’s using an Arduino to spoof the existence of a CD changer, which allows him to inject an audio signal into one of the pins on the back of the radio. Eventually he wants to move this task over to the ESP32, but he says a big change like that will have to wait until warmer weather.

This isn’t the first time we’ve seen the Raspberry Pi used to add enhanced features to a somewhat older vehicle. While some bemoan the increased complexity of modern vehicles, it seems some hackers can’t get enough of it.

Continue reading “Raspberry Pi Takes Over Volvo’s Integrated LCD” →

TRS-80 Model 100 Gets 64-Bit CPU And A Very Wide LCD

January 17, 2021 by 32 Comments

To say the TRS-80 Model 100 was ahead of its time would be something of an understatement. It had a high-quality mechanical keyboard, phenomenal battery life, plenty of I/O and expansion capabilities, and was actually small and light enough to easily carry around. While its layout might seem to be a bit dated to modern eyes, there’s little debate that it was one of the most successful and influential computers in history.

So it’s little surprise that [belsamber] thought the Model 100 might make an ideal platform for his mobile command line work. With a few modifications, naturally. While technically the nearly 40 year old portable could connect to a Linux computer as a simple serial terminal, its outdated and non-backlit LCD leaves a bit to be desired in 2021. But there’s little sense in upgrading the display if he’d still be saddled with the anemic Intel 80C85 motherboard, so he decided to clean house and replace everything.

Once stripped of the original hardware, the Model 100’s enclosure offered up plenty of room for a Pine A64 LTS single-board computer, four 18650 cells, and a 1920×480 ultra-wide LCD. While not a perfect match for the dimensions of the original panel, the new screen is an exceptionally close fit. The keyboard has been left intact, but rather than adding a QMK-compatible microcontroller to the mix, [belsamber] wired the matrix directly into the GPIO of the A64.

While we know some retro aficionados might shed a tear to see an iconic computer get gutted, [belsamber] mentions that nothing will go to waste; the parts he pulled from this machine will serve as spares for a second Model 100 he has in his collection. Besides, given the immense popularity of these machines, they aren’t exactly rare to begin with.

As an aside, we recently saw this same unique display used in a 3D printed desktop computer with distinctively retro-futuristic styling. We didn’t have miniature 4:1 ratio displays on our list of 2021 hardware predictions, but it seems they’re already making a strong showing.

A Portable Serial Terminal That Should Be From The 1970s

December 8, 2020 by 38 Comments

The humble standalone serial terminal might be long gone from the collective computing experience, but in the ghostly form of a software virtual terminal and a serial converter it remains the most basic fall-back and essential tool of the computer hardware hacker. [Mitsuru Yamada] has created the product that should have been made in the serial terminal’s heyday, a standalone handheld terminal using a 6809 microprocessor and vintage HP dot matrix LEDs. In a die-cast box with full push-button keyboard it’s entirely ready to roll up to a DB-25 wall socket and log into the PDP/11 in the basement.

Using today’s parts we might achieve the same feat with a single-chip microcontroller and a small LCD or OLED panel, but with an older microcomputer there is more system-building required. The 6809 is a wise choice from the 1970s arsenal because it has some on-board RAM, thus there’s no need for a RAM chip. Thus the whole thing is achieved with only a 2716 EPROM for the software, a 6850 UART with MAX232 driver  for the serial port, and a few 74 chips for glue logic, chip selects, and I/O ports to handle keyboard and display. There’s no battery in the case, but no doubt that could be easily accommodated. Also there’s not much information on the keyboard itself, but in the video below we catch a glimpse of its wiring as the box is opened.

The value in a terminal using vintage parts lies not only in because you can, but also in something that can’t easily be had with a modern microcontroller. These parts come from a time when a computer system had to be assembled as a series of peripherals round the microprocessor because it had few onboard, leading to a far more in-depth understanding of a computer system. It’s not that a 6809 is a sensible choice in 2020, more that it’s an interesting one.

By comparison, here’s a terminal using technology from today.

Continue reading “A Portable Serial Terminal That Should Be From The 1970s” →

Speeding Up Drawing To MCU-Connected Serial Displays

September 23, 2019 by 13 Comments

Writing image data to serially connected (SPI/I2C) displays from a microcontroller is easy enough these days, courtesy of standards defined by the MIPI Alliance, yet there are some gotchas in it which may catch someone using it unaware. [Larry Bank] wrote up a good summary of how one can get maximum performance out of such a display link.

At the core is the distinction between pixel data and command transmissions. The change from command to pixel data mode requires signaling, which takes precious clock cycles away from transferring pixel data between the MCU and display. The common MIPI DCS instruction set allows for a big reduction in needed data transfers by allowing parts of the display to be addressed instead of requiring a full refresh. Yet by not properly segmenting command and data transfers, one ends up unnecessarily slowing down the process.

The result is that one can run something like a Pac-Man emulator on an AVR MCU with a sluggish 320×480 SPI LCD at 60 FPS, as one can see in the video that is embedded after the break. Check the article for another demo video as well.

Continue reading “Speeding Up Drawing To MCU-Connected Serial Displays” →

Manual LCD Makes Information Display Tedious, Educational

April 28, 2017 by 28 Comments

The HD44780 is one of the first chips we learned about as a kid, and chances are good you’ve used one in your project at some point, and almost certain that you’ve interacted with one in your life. The character LCD is ubiquitous, easy to interface, and very robust. They come in sizes from 8 x 1 to 20 x 4 and even larger, but they almost all have the same pinout, and there are libraries in many embedded environments for interacting with them. [The 8-Bit Guy] decided to interface with one using just switches and a button, (YouTube, embedded) with the intent of illustrating exactly how to use them, and how easy they are.

Continue reading “Manual LCD Makes Information Display Tedious, Educational” →