A Look Back At Computer Displays

These days, our video cards are actually as powerful as yesterday’s supercomputer and our monitors are bigger than the TVs most of us had as kids. But how did we get there? [RetroBytes] covers computer displays starting with the Colossus computer to today.

Back in the days of Colossus, of course, a display was actually a TeleType-like device printing on a roll of paper. The Manchester Baby actually had a crude display which was actually a Williams tube (no relation) that used phosphor persistence to store data. You could physically see memory on the tube or monitor it on a parallel tube — an early form of memory-mapped display.

Continue reading “A Look Back At Computer Displays”

Re-reclaimed From Nature: Resurrecting A DT80 Terminal

When Datamedia announced their new DT80 terminal as a VT100 killer back in 1979, they were so confident of its reliability, they threw in a full one-year warranty. Now, decades later, that confidence is once more put to the touch after [RingingResonance] fished one such terminal out of a creek by an old illegal dumping site. Not knowing what to expect from the muck-ridden artifact, his journey of slowly breathing life back into the device began.

Brings new meaning to the term “rooted”

Considering the layers of mud and roots already growing all over the main board, one can only assume how long the terminal has actually been in there. But cleaning it from all that was only the beginning: some components were missing, others turned out to be broken, including some of the ROMs, which [RingingResonance] speculates may have been caused by lightning which determined the DT80’s fate in the first place.

That’s when the adventure really started though, digging deep into the terminal’s inner life, eventually writing a debugger and own firmware for it. That code, along with all other research, notes, and links to plenty more pictures can be found in the GitHub repository, and is definitely worth checking out if you’re into the technologies of yesteryear.

Despite the DT80’s claimed superiority, the VT100 prevailed and is the terminal that history remembers — and emulates, whether as tiny wearable or a full look-alike. But this fall into oblivion was also part of [RingingResonance]’s motivation to keep going forward restoring the DT80. Someone had to. So if you happen to have anything to contribute to his endeavours or share with him, we’re sure he will appreciate you reaching out to him.

Continue reading “Re-reclaimed From Nature: Resurrecting A DT80 Terminal”

2:3 Scale VT100 Terminal Gets Closer To Its Roots

When [Michael Gardi] finished his scaled down DEC VT100 replica a few months ago, he made it very clear that the project was only meant to look like a vintage terminal on the outside. A peek into the case revealed nothing more exotic than a Raspberry Pi running its default operating system, making the terminal just as well suited to emulating classic games as it was dialing into a remote system. But as any hacker knows, some projects end up developing a life of their own.

It started simply enough. The addition of an RS-232 Serial HAT to the Raspberry Pi meant that the 3D printed VT100 could actually operate as a serial terminal using software such as minicom. Then [Lars Brinkhoff] got involved. He loved the look of the printed VT100, and thought it deserved better than a generic terminal emulator. So he went ahead and started developing a custom terminal simulator for it to run.

Reliving those CRT glory days.

The idea here is that an an 8080 emulator actually runs an original VT100 firmware ROM, warts and all. It makes all the beeps and chirps you’d expect from the real hardware, and there’s even some OpenGL trickery used to mimic an old CRT display, complete with scan lines and a soft glow around characters.

Naturally the visual effects consume a fair amount of processing power, so [Lars] cautions that anything lower than the Pi 4 will likely experience slowdowns. Of course, nothing is stopping you from running the simulator on your desktop machine if you’re looking for that classic terminal experience.

Did this gorgeous recreation of the VT100 need to have a true serial interface or a simulator that recreates the unique menu system of the original? Not at all. Even without those additions, it blew us away when [Michael] first sent it in. But are we happy that these guys have put in the time to perfect this already stellar project? We think you already know the answer.

Ask Hackaday: Are 80 Characters Per Line Still Reasonable In 2020?

Software developers won’t ever run out of subjects to argue and fight about. Some of them can be fundamental to a project — like choice of language or the programming paradigm to begin with. Others seem more of a personal preference at first, but can end up equally fundamental on a bigger scale — like which character to choose for indentation, where to place the curly braces, or how to handle line breaks. Latest when there’s more than one developer collaborating, it’s time to find a common agreement in form of a coding style guide, which might of course require a bit of compromise.

Regardless of taste, the worst decision is having no decision, and even if you don’t agree with a specific detail, it’s usually best to make peace with it for the benefit of uniformly formatted code. In a professional environment, a style guide was ideally worked out collaboratively inside or between teams, and input and opinions of everyone involved were taken into consideration — and if your company doesn’t have one to begin with, the best step to take is probably one towards the exit.

The situation can get a bit more complex in open source projects though, depending on the structure and size of a project. If no official style guide exists, the graceful thing to do is to simply adopt the code base’s current style when contributing to it. But larger projects that are accustomed to a multitude of random contributors will typically have one defined, which was either worked out by the core developers, or declared by its benevolent dictator for life.

In case of the Linux kernel, that’s of course [Linus Torvalds], who has recently shaken up the community with a mailing list response declaring an overly common, often even unwritten rule of code formatting as essentially obsolete: the 80-character line limitation. Considering the notoriety of his rants and crudeness, his response, which was initiated by a line break change in the submitted patch, seems downright diplomatic this time.

[Linus]’ reasoning against a continuing enforcement of 80-char line limits is primarly the fact that screens are simply big enough today to comfortably fit longer lines, even with multiple terminals (or windows) next to each other. As he puts it, the only reason to stick to the limitation is using an actual VT100, which won’t serve much use in kernel development anyway.

Allowing longer lines on the other hand would encourage the use of more verbose variable names and whitespace, which in turn would actually increase readability. Of course, all to a certain extent, and [Linus] obviously doesn’t call for abolishing line breaks altogether. But he has a point; does it really make sense to stick to a decades old, nowadays rather arbitrary-seeming limitation in 2020?

Continue reading “Ask Hackaday: Are 80 Characters Per Line Still Reasonable In 2020?”

Hackaday Links Column Banner

Hackaday Links: August 6th, 2017

We get a lot of Kickstarter pitches in our email, but this one is different. First of all, it’s over. No biggie there. Secondly, it’s a laser-cut hurdy gurdy. What’s a hurdy gurdy? It’s a musical instrument that uses a wheel to vibrate strings. It has drone strings and a rudimentary keyboard for the melody. Think of it as ‘string bagpipes’ and you’re not that far off. This means you can laser cut (or 3D print, someone get on it) a hurdy gurdy, and that’s just awesome.

I wrote the previous paragraph without referencing Donovan. You’re welcome, Internet.

[Spencer] found a few very small seven-segment flip display units. This, of course, meant he had to build a clock. Right now [Spencer] is in the PCB design stage of the project, with the hope of finishing it before school starts. There is still an open question here: where do you get really tiny flip segment displays?

Perhaps we’ve said too much about the number one badge at this year’s DEF CON, but this is really the project that just keeps giving. [Hyr0n] thought it would be a great idea to have a shirt printed with the design of this year’s official Hackaday DEF CON badge. This seemed simple enough — all he needed to do was send the design off to a custom printed t-shirt place on the Internet and wait a week or two. This is where things got a little nuts. [Hyr0n] stole my intellectual property. My very intellectual property. Here’s a great tip for when a t-shirt place puts your order on hold because of a copyright: just say it’s creative commons, they’ll send it right on through.

The DIY-VT100 is a miniature VT100 (and VT102) terminal, because sometimes you need a standalone serial terminal. Soon, it’s going to be a Crowd Supply campaign. Who’s going to be the first to 3D print a look-alike VT100 enclosure for this little thing? Where can you get pre-bromiated filament?

We all know what the Atari 2600 is, but what is the Atari 2700? It’s an exceptionally rare prototype that used wireless controllers. One was found in a thrift store recently. [L064N] bought it for $30, and sold it on eBay for $3000.

Here’s a weird thing [Yann] sent in. The Rise mP6 was a non-Intel, non-AMD, non-Cyrix, non-VIA, x86 compatible CPU sold in the late 90s.  What’s cool about it? Three parallel MMX instructions, and an easter egg hidden in the microcode. The principal engineer on the project, [Chris Norrie], decided he wanted to hide his name in the CPU, and managed to do it without anyone else catching on. If you put ‘NZ’ into eAX and execute CPUID, it returns “* Chris Norrie *”. That’s a hack, and it’s amazing.

Wireless Terminal Over ESP8266

From debug messages to the fundamental ‘hello world’, serial communication does it all over three little wires. Now imagine being able to cut the cord to your next microcontroller project and use your phone as a VT100 terminal. This was the premise of [Ondřej Hruška]’s Wireless Terminal Project where he took an ESP8266  and added an in-browser terminal emulator which can be accessed over WiFi. The final hardware uses an ESP-01 module mounted atop a breadboard adapter with a 3.3V LDO, protection circuitry for the pins and under-voltage disable.

The firmware is based on [SpriteTM]’s libesphttpd code which was modified to include the VT100 escape sequence parser. The parser, in turn, was coded as a state machine and compiled using Ragel which simplifies such projects greatly. When you access the tiny web server, the loaded webpage starts to communicate over web sockets to the ESP-01. Key-presses from the terminal are sent to the buffer and onto the parser and control logic. The characters are then passed to the hardware UART lines at 115200bps and if an escape sequence is detected, the corresponding action is executed instead.

[Ondřej Hruška] shares the code as well as a user manual in PDF for anyone who would like to try it out and help improve the project. With a little inspiration on learning about state machines, you could extend the project to your own use case as well.

Thanks for the tip [Marco Saarloos]

Hackaday Prize Entry: Pocket Serial Terminal

When you have a microcontroller or other microcomputer on the bench in front of you and it lacks the familiar keyboard and display of a modern desktop computer, what do you do when you wish to program it or otherwise issue commands? Unless you are a retro computer enthusiast who longs for a set of Altair-style toggle switches, the chances are you’ll find its serial port and attach a terminal.

Serial terminals, devices containing a screen and keyboard hooked up to send and display text from a serial port, used to be a staple of computing, but as standalone devices, they’re now rather rare. In most cases nowadays using a serial terminal will mean opening up a terminal emulator in your modern OS, Linux, Windows, or MacOS, but there is still a use for standalone hardware. [Kuldeep Singh Dhaka] certainly thinks so, because he’s making an extremely nice portable terminal with an LCD screen.

The terminal emulates a venerable DEC VT-100 terminal, but since it’s built around an STM32F105 ARM microcontroller we’re sure it could emulate other models with appropriate software. It takes either a USB or a PS/2 keyboard, so we’d expect to see it paired with a suitably tiny portable keyboard when it in use. There is no source code available for it yet since this is very much still a project in development that we’re featuring now because it is a 2017 Hackaday Prize entry, but he assures us that code will be on its way and it will be GPL licenced.

He’s even posted a video that we’ve placed below the break of the device in operation, connected to a machine running MicroPython. We’d probably turn off that beep, though.

Continue reading “Hackaday Prize Entry: Pocket Serial Terminal”