In Search of the Perfect, Portable Pocket Terminal? Sometimes There's No School Like the Old School!

Sulfuroid still likely hasn't actually slept since our last article, covering the nearly never-ending stream of productivity that emanates from his offices...

Concerns for his health aside, we are quickly filled with awe over his latest project, which aims to turn the venerable legacy workhorse that is the Texas Instruments TI-92 scientific calculator into the perfect, pocket-sized processing terminal!

This looks to be an ideal reference project for retrofitting new hardware into a retro enclosure, and the steps to do so are so wonderfully demonstrated by Sulfuroid, that we can't help but take a look at his process in the write-up that follows!

A change of flow...

With the advent of 3D printing, many of us will nowadays design a PCB first, then the box to fit around the board, safe in the knowledge that we can create custom enclosures with very little effort, and simply print them out on the nearest Ultimaker.

That process gets turned around when you already have an existing enclosure however, and the board becomes the thing that needs to be designed to match the existing casework.

Fortunately, there are some tricks you can put into practice to make this a whole heap easier, so let's follow along with Sulfuroid as he goes back in time, and starts deconstructing the retro PCB, ready to replace it with something a bitmore powerful, perhaps with a bit of a Raspberry kick to its flavor...? 😉

Poking around under the plastics...

Pop the hood on the TI-92, and you're treated to a sea of gold and green — nearly all of the front face of the main PCBA is made up of a matrix of squiggly circular exposed plated copper patterning.

These interdigitated circular pads form the contacts of the key switches, which are to be activated by the press of the conductive rubber boots that sit on the rear face of the keyboard button matrix.

If your volumes are high enough, you can save the cost of what would otherwise be significant amount of tactile switches — that is, provided you can spread the cost of the tooling required to create that conductive rubber matrix across a high enough number of units!

This method of design also means it's pretty easy to recreate the board layout. The first step in doing so is to strip the front face of the PCB of components.

As the switches are formed of copper tracking, this leaves merely the display itself to remove — the aftermath of this can be seen above.

With the front face of the board now fully flat, we keep with the theme of retro tech and bust out the flat bed scanner, the noises of which you've likely not heard in quite some time!

Scanning the flat face of the board into your CAD package of choice gives you a solid reference from which to start reconstructing the board outline as a DXF file. With a rough trace of the outline and mechanical elements (such as, all of those keypad contacts and various slots).

We mentioned the flatface of the board being scanned in. That's absolutely fine for the front of this vintage bit of tech. What about the rear face of the board, where all those components of yester-year are located?

Oooph. Better smash that F key, because this board is now officially a mechanical space model.

But, sometimes progress is prefixed by pain, and the amount of pain in seeing this premium pocket number pusher reduced to scrap FR4, means there is surely quite a bit of progress to be made...

Dead boards to digital DXFs...

Using your CAD program of choice will mean that the exact steps taken might vary here and there, but ultimately, you'll look to sketch a drawing around the scanned image with dimensions supplemented from manual measurements.

This is where a good set of Vernier calipers will pay for themselves!

With such a model in hand, nearly every CAD package will have a feature to export your new model as a 2D DXF. Why would you do this? Well, KiCad has a lovely feature to import that DXF file, enabling you to drop it directly into the board outline layer.

Further imports to different layers can allow you to also bring in all of those button keypad elements, etc. choosing the required KiCad board layer to import to each time.

Bash the buttons!

With the locations of all the physical board elements defined, Sulfuroid turns his attention to the smaller details.

First and foremost, the key to reuse of the original button matrix keypad is defining a copper pattern to use for the contact set of each key.

This serpentine zig-zag of copper provides a contact set that is likely to form a closed circuit, even if the force pressing down on the button isn't 100% "on center."

It's always nice to see how well KiCad renders even complex copper geometry like these pads, exactly as you'd expect them to look in real life!

With a little bit of copy and paste, the entire front face of the new PCB quickly gets a little bit less green, and a little bit more golden.

With this keyboard soon to house a Compute Module — the exact flavor of which is still to be determined — the liberation of all the space previously required by the old circuitry means that there is loads of room to comfortably track out this button matrix.

We can see that even with the footprint of a RPi Zero thrown into the layout below, there is still more than enough room to accommodate anything that Sulfuroid might deem fit to add to his Pi-92.

We can see a few additional components already gracing the rear face of the PCB layout, so what's already made the cut into this Pi-based palm-top?

Scoping out that schematic...

Well, let's cut straight to the chase, and address the slight issue of addressing that many button elements!

The majority of the schematic page seen above is dedicated to constructing a matrix of rows and columns that allow connections to the button contacts to be read out over I2C, by scanning the entire button array with a TCA8418 — offered by Texas Instruments.

Its 18 I/O pins allow for a matrix construction of up to 80 key elements, which is far more than the Pi-92 uses, but as it's packaged as a WQFN-24, there's no need to look for a smaller part — the 4mm x 4mm package isn't going to need to be any smaller on a board of this size!

The device is a great way to abstract what would otherwise be a GPIO nightmare into a simple, I2C-accessible set of registers!

Tippy-tappy touchscreen!

One of the main features that will set the Pi-92 apart from its Ti-92 predecessor is the integration of a full color 4" touchscreen, which sits directly in place of the previous monochrome LCD.

It's one thing to have a full graphical Linux desktop sat in your pocket, but even the most hardcore terminal enthusiast will agree that running something like Raspbian, or any other of the graphical desktop distributions can be made much easier with some... well, graphical interaction!

While that directional D-pad will likely be repurposed with the ability to control the mouse pointer as needed, that can get pretty tiresome in comparison to say, the simplicity of "Point 'n click" that a touchscreen offers.

These 4" displays can be found on breakout boards galore, intended for use with the various embedded solutions that adorn our desktop workspaces.

When you buy these displays as a module, you often will find a SSOP-16 packaged IC on the reverse of the board.

This is more often than not going to be the XPTEK XPT2046, which is a 4-wire resistive touchscreen controller, which lets the X/Y coordinates of a pen touch be read out over SPI. Neat!

Sulfuroid is, of course, implementing this functionality directly on his main board, so it's no surprise to see this part sitting neatly in the schematic. You can check out the details of the implementation in the schematic snippet below.

Make the most of that SPI bus...

With SPI already employed as the data transport between the host controller, and the touchscreen controller, why not see what else can be abstracted to a serial interface?

It turns out that even the display itself will happily sit as an SPI device, which results in a far, far lower pin count needed to drive it.

Engineering is always a balancing act, and despite the simplicity gained in interfacing to this screen with SPI, there will be a tradeoff in how fast the display can be updated — a parallel interface is a bit more work to implement, but the refresh rates can be worth it.

However, again, SPI does have its advantages — not least in that it means this keyboard / display combo can be driven from nearly any SPI enabled MCU, even if a Linux SBC is going to be used here!

With the huge amount of work that Sulfuroid has ably graced our project pages with previously, it's no doubt that this will be an incredible bit of kit once completed.

We're making you aware of this project as it happens though, so that you can see the design process in action. With Twitter updates that certainly make for better reading than other, well known prolific tweeters... (enough said), you'll likely not regret following along for the ride by making sure Sulfuroid is on your list!

If you less font of all the twits and tweets, the GitHub repo is updated almost as frequently — containing most of the project sources already!