Siri Like it’s 1976 With a TI Silent 700 Terminal

The year is 1976: disco is just starting to take off, Americans were still reeling from Watergate, and for the price of a Datsun you could purchase a TI Silent 700 Model 745 terminal. The Silent 700 series of terminals were not computers, despite the Model 745 having an Intel 8080 microprocessor. Terminals are intended as interfaces for computers, and the Model 745 could connect to a computer via a serial connection or with acoustic coupling. Input was handled with a keyboard, and output was printed on a roll of thermal paper.

I recently became interested in taking up retrocomputing as hobby, and when I came across a TI Silent 700 Model 745 at a local industrial auctions a project came to mind. What if I could make this vintage piece of technology perform tasks that were cutting-edge just a few years ago? Something about the juxtaposition of a ’70s paper-based terminal doing something modern just had a kind of poetic beauty to me.

The project I decided to attempt was to create a 1976 version of Siri (or Alexa, Google Now, etc.). The user would type in a question, and the TI Silent 700 would print out an answer. It seemed like a fun piece of interactive history that guests could play with (better than it sitting and gathering dust). In theory, this seemed like a pretty easy project: it’s a terminal designed to connect to a computer, and it’s capable of serial communication. It seemed like a simple task to connect it up to a Raspberry Pi and run some question-answering software.

Of course, these things never end up being quite so easy do they? They were a few major challenges to overcome to get his project complete:

  • Getting serial communication with a Raspberry Pi working
  • Running software that could answer questions from the terminal
  • Designing and making an unobtrusive case for the electronics

Finding the TI Silent 700 Model 745

I’ve been going to industrial auctions here in Denver for years. Originally, it was just to find tools for my home shop. When I started my fabrication business, I bought lots of large machinery there (like CNC machines, mills, etc.). These days, I mostly keep an eye on the auctions to find unique or interesting curiosities. I’m always fascinated by the kinds of things I come across.

That’s how I felt when I came across the Silent 700. I figured I could get it for dirt cheap — after all, who has any practical use for something like this anymore? Well, apparently there was another geek out there, and after a mild bidding war I ended up paying $37.50. Not a terrible price, but more than I was originally planning on paying (especially since it was online, and I didn’t even know if they thing turned on). Oh well, I had the terminal and was excited to get started.

It was important to me to leave the actual terminal completely unmodified. In my mind, it’s a piece of computing history, and hacking it apart would be a travesty. Sure, the TI Silent 700 was a pretty popular device, and they’re not exactly rare. You can find a handful of them on eBay right now for under $200. But, still, I just couldn’t stomach the idea of destroying such a neat piece of tech.

So, I decided on a simple course of action: get the terminal talking to a Raspberry Pi using the existing serial communications port, make sure everything worked, then design and 3D print a separate case for the Raspi. The Silent 700 would remain unmodified and original, but from a user standpoint it would appear to be doing things a ’70s “computer” shouldn’t be able to do.

The Serial Communication

When I was planning this project, I expected that getting serial communication working between the Raspi and the Silent 700 to be the easiest part. I already had experience with serial communication from that era (from working with old CNC mills), and knew that the Raspi could handle serial connections through the GPIO pins. Getting them talking should have been a simple matter of connecting the right pins and enabling the serial console on the Raspi —  or so I thought.

I decided to use a Raspberry Pi Zero W for obvious reasons: it’s cheap, it’s tiny, it has built in wireless, and it can be setup completely headless. That last part was important, as my stockpile of electronics was all given away when I went to live out of a camper. I didn’t have a keyboard, or a monitor. I didn’t even want to have to get a mini-HDMI adapter to connect it to my TV. So, being able to go completely headless right from the start was very important (and Adafruit has a guide that was very helpful here).

After getting the install done (and SSH working), I started trying to get some sort of serial communication happening with the terminal. That’s when I ran into my first hurdle: the Pi Zero W’s mini-UART. Unlike other Raspberry Pis, the Zero W has two UARTs. The primary UART is used for bluetooth, and the less-capable mini-UART is available for serial communication.

Unfortunately, the mini-UART isn’t capable of handling the requirements of the Silent 700 (300 baud, 7 data bits, parity bit, start and stop bits). It took quite a while for me to realize the STTY settings weren’t taking because the mini-UART was being used. Switching serial communication to the primary UART (and disabling bluetooth) allowed me to use the settings the Silent 700 needed.

This got some communication happening, unfortunately it was all gibberish. Characters sent from the terminal to the Raspi would show up as completely different characters on arrival (and vice versa). I suspected that it was a problem with my serial settings (information on the Silent 700 was sparse afterall). Maybe it was a parity problem? Or some sort of issue with ASCII character encoding?

I spent days trying everything I could think of, and was on the verge of giving up. I had tried every possible setting and wiring change — or so I thought. That’s when I was doing research for Hackaday (where I write), and came across this great biosrhythm article RS-232 (serial) on a Commodore PET. It seemed like a fun project, so I was happily reading along when I came across this paragraph:

Next I wanted to troubleshoot the characters not being displayed right. First thing was maybe it was the wrong number of data or stop bits or even parity. I tried many different combinations: 7n1, 7e1, 8e2, etc. None of them seemed to make a different. Typing the alphabet “abcdef..” seemed to return the alphabet but in seemingly reverse order with some other characters interspersed.

Hmmm… this seemed remarkably like what I was experiencing. Using an oscilloscope, he realized that the logic levels were reversed (a problem I had never heard of). Normally, logic signals are inverted: high is false, low is true. But, some devices are “non-inverse”. The Commodore PET was, maybe my Silent 700 was too?

I grabbed my Arduino and wrote a quick program to reverse the logic of the serial signals. Two pins were used for transmit signals from the Silent 700, and two for the Raspi. For each, one pin would act as an input, and then second pin would simply output the reverse of whatever state the input was in. As soon as I powered everything back up, I had coherent serial communication. The 1976 Silent 700 was talking to the 2017 Raspberry Pi!

Answering Questions Like Siri

As soon as I had the serial communication working, I enabled the Raspi serial console at boot. Immediately two problems became apparent: 1. Linux outputs a lot of text when it boots, which is an issue when everything has to be printed at a mere 30 characters per second, and 2. the Model 745 can only output in uppercase. Most tasks in the Linux terminal require lowercase for most (or all) of the commands. Huh, how to deal with that?

The first problem was solved by silencing the boot up messages to the bare minimum. This required a handful of settings changes, but is pretty easy after a few minutes of Googling. After silencing everything I could, I was down to just 7 lines of text being printed on the Silent 700 (totally manageable).

Solving the problem of uppercase-only input from the Silent 700 was a bit more labor intensive. STTY is supposed to have a feature for converting all input to lowercase, but this doesn’t seem to work in Linux (or at least Raspbian). Even if it did work, there are some commands which do need uppercase letters (like stty -F /dev/ttyAMA0 itself). The solution, while painstaking, was to create a bunch of command aliases that were all uppercase so they could be entered from the terminal. The login username and password also had to be made uppercase.

With the ability to type commands on the Silent 700, I just had to find a question/answer service that could be run from the Linux terminal. I tried a few, including Mycroft and Jarvis. Jarvis didn’t seem to work at all, and Mycroft was okay but glitchy and the CLI was cluttered for the task of running on a paper-based terminal. Mycroft is also a heavy install, considering it has voice-command abilities (which I didn’t need).

I ended up settling on the Wolfram Alpha API, which is nicely customizable, easy to use and get an API key for, and can handle a wide range of question types. I found a nice bash script to get started with, but it output too much information. I just wanted a short answer, to make the output more user-friendly on the Silent 700. Luckily, Wolfram Alpha has a method for this. Sections of the result are divided into “pods,” and the second pod almost always has the most basic answer (the first displays their interpretation of your question).

After tweaking the bash script to only show the second pod, I got what I wanted: simple printed answers to a wide variety of questions! The user simply types “TERMI ” and gets an answer back. It’s like having Siri or Alexa on an electronic typewriter. Fun! I also put in a few other basic commands (like the ability to Tweet, or play Zork). I’ll probably expand what Termi is capable of, once I think of some interesting tasks.

Packaging it All

The final step of the project was to design and print a case for the electronics. I originally planned on using a hardware circuit to handle inverting the serial logic, but ended up just using an Arduino Pro Mini. At just a few dollars, it’s cheap and will allow me to add some IoT capabilities for Termi in the future.

Considering my career in mechanical design, and my 3D printing experience, this ended up being the easiest step. I wasn’t too concerned with making the case super compact, I mostly just wanted it to be aesthetically pleasing and unobtrusive. I settled on a simple case with the DB15 connector built into it (instead of using a separate serial cable).

I felt like this made it feel more like a single device. I’ve also always kind of hated small cases being attached to heavy cables (like serial cables), because the case never lays flat on the table. It just gets pushed around by the cable — small pet peeve there. So, the case plugs into the serial port on the Silent 700, and sits nicely out of the way in the back. It has it’s own power cord, but other than that it’s pretty self contained. And that’s it! The project is complete for now!

3 replies
  1. Paul Rickards
    Paul Rickards says:

    Very cool! Glad the Commodore PET RS-232 project helped debug the inverse logic levels (only on the specific software I was using on the PET). It must have been a standard and then changed at some point. Neat terminal– I’d like to have one some day.

    Reply
    • Cameron Coward
      Cameron Coward says:

      Thanks! It’s been a fun project, but I was completely drawing a blank until I came across your article! I had never heard of logic being inverted like that. I tried to decipher the issue based on what was being sent in binary, but I didn’t consider the inverting issue because it wasn’t apparent when I looked at the whole picture (with parity and stop bits). So glad I came across your article! I’ll definitely be following your site, and will write about the cool stuff on Hackaday!

      Reply

Leave a Reply

Want to join the discussion?
Feel free to contribute!

Leave a Reply