Introduction

Originally created by Eric Volpe in 2016, this design is relatively simple yet extremely versatile. It's also very inexpensive. The interface allows for any computer equipped with a USB port to act like another teletype on the loop. The computer sees the device as a simple serial interface, which can easily be manipulated by very simple text-based programs.

The device has a high voltage side where the current loop passes through by way of a couple of terminal block pairs. A pair of optoisolators handle RX and TX-- one is triggered by the current loop and is read by the microcontroller, and one keys the loop being controlled by the microcontroller. This allows for two way communication via the interface.

The device is based on the Atmel Atmega 16u2/32u2 chip, where all the logic happens.

Capabilities

• On-board conversion of ASCII text from the computer to ITA2 (Baudot-Murray) on the current loop and vice versa (for 5-bit machines)
  
  • This can be disabled if your software passes ITA2 encoded text to the serial interface; if disabled, the board does no translation of encoding
• Pass-through of ASCII encoding for 7/8-bit machines
• Other character encodings – customizable translation tables can be configured to enable other encodings outside of ITA2 and ASCII
• 45 and 110 baud rates have been tested the most, but other common rates (and probably all uncommon rates for that matter) used in teletypery should work without problems
• 20ma and 60ma current loops supported (current levels both lower and higher are safe depending on the exact optoisolators used, though it would be unusual to see other currents in use)
• All typical loop voltages supported-- in theory voltages as low as ~5VDC or as high as ~200VDC are possible depending on the optoisolator used in your particular iteration of the board

FAQ

• Will this board work with model X teleprinter? If it uses a current loop, then most likely. Pretty much any ITA2 or ASCII, 45+ baud, 20ma or 60ma current loop machine should work with this board. Even if you have an unusual type of loop, baud rate, or 5-bit encoding, chances are the board can still be made to work with your oddball machine.
• Will this board work with X computer or X operating system? Almost certainly-- it shows up as a simple serial interface as far as the computer's concerned, so almost anything remotely modern should be able to drive it. It has been most extensively tested on a few flavors of Linux, MacOS, and Windows, however. The computer must also support USB, of course.
• Does this board demodulate RTTY? No, this board is not a TU. However, it could be used in tandem with demod software such as fldigi to act like a poor man's TU, as has been done with ttyBash. The designer of this board has also designed an RTTY demod board. I have considered doing a run of these boards one day, too.
• Does this board require an external loop power supply? Yes. This board does not provide any power to the loop.
• Does the polarity of the loop matter? Nope. There is a bridge rectifier added to the RX_LOOP circuit, which allows for the loop to be wired in either polarity.
• Does this support full duplex or half-duplex? Yes. <This should probably move to be its own section down below>
  • The most common mode is probably half-duplex, meaning you have a single current loop to which your teletype keyboard and printer are wired in series (or just the printer if it's an RO unit). This is achieved by bridging the TX and RX terminals with a bit of hookup wire between the center terminals <image to come to better illustrate this>. Then the single loop must be wired to the outermost terminals.
  • Full duplex involves two electrically isolated current loops-- one for your keyboard (RX on the board), and one for your printer (TX on the board). Full-duplex can be achieved by removing the jumper between the TX and RX terminals and simply wiring the two loops to the two pairs of terminals <image to come to better illustrate this>.
• Are there any recommended loop power supplies? There is a great selection of tried and true supplies outlined here <link to be added later>.
• Must I use a fuse on the current loop circuit? Technically no-- it's not very likely you'll ever need it since if a dangerous over-current occurs on the loop, the current limiting resistor you put into series will almost certainly fail open, protecting the board and the teletype's selector magnets. However, I prefer to be extra safe and fuse my loops to protect my boards and magnets from the unlikely event of an overcurrent that causes the resistor to fail closed or the resistor only fails after the board and/or magnets are fried. I also prefer to fuse to protect from the more likely event that I do something stupid.

Procure one Ready-Made

This board has been manufactured in bulk at least three times and probably will be again at some point in the future. If we know about any future manufacturing runs, we'll include details here:

Build Your Own

One of the great things about this board is that all of its components have through-hole counterparts, so a somewhat solder-savvy person can procure parts and assemble boards by hand. Those with the skills and equipment for SMT can, of course, stick with the SMD components, or a run could be manufactured at any reputable fab house.

Schematics, BOM, &c.

more to come

Tips for Assembling Through-Hole

same here

How to Use - Setup & Normal Use

First - Wire the Board to the Current Loop

To begin, you will need to wire up the board in series to your current loop, just as you would another teletype. Also ensure there IS another teletype on the current loop, or this exercise will be pointless. 

If your teletype's keyboard and printer are both wired up to the same current loop so that whatever you type on the keyboard is also instantly printed on the same machine's printer, then you will want to wire up your board in half duplex, single loop mode (this is most common). To do this, simply put a small bit of hookup wire between the innermost TX and RX terminals, as depicted below (TO ADD IMAGE). If you purchased a board through me, then the hookup wire should already be in place. Then wire the remaining two outermost terminals in series to the loop-- think of one as input and one as output. Polarity doesn't matter. When finished, your loop should look something like this (TO ADD DIAGRAM BELOW).

If your teletype's keyboard and printer are wired up to separate current loops so that anything you type on the keyboard is NOT printed on the same machine's printer but is rather meant to only be printed at a remote machine's printer, then you will want to wire up the RX and TX terminals to the two separate current loops. Polarity doesn't matter on either loop. This is full duplex mode. This is a less common setup but is not entirely uncommon. When finished, your two loops should look something like this (TO ADD DIAGRAM AND IMAGE).

Once this is done, plug the board into the computer and turn on the current loop power supply and any machines on the loop you wish to test with.

Second - Set Up the Board for First Use

On Linux

teletype@ttynode:~$ dmesg
[    0.000000] Booting Linux on physical CPU 0x0

<...lots of log output here...>

[  106.305973] usb 1-1.2: USB disconnect, device number 4
[  108.141105] usb 1-1.2: new full-speed USB device number 5 using dwc_otg
[  108.285479] usb 1-1.2: New USB device found, idVendor=1209, idProduct=4545
[  108.285490] usb 1-1.2: New USB device strings: Mfr=1, Product=2, SerialNumber=220
[  108.285499] usb 1-1.2: Product: Teletype Interface
[  108.285507] usb 1-1.2: Manufacturer: Slothco Enterprises
[  108.285514] usb 1-1.2: SerialNumber: 95735343533351916120
[  108.286784] cdc_acm 1-1.2:1.0: ttyACM0: USB ACM device

SUBSYSTEM=="tty", ATTRS{serial}=="SERIALNUMBER", SYMLINK+="tty-int1"

teletype@ttynode:~# ls -l /dev/tty-int1
lrwxrwxrwx 1 root root 7 Sep  6 22:59 /dev/tty-int1 -> ttyACM0

teletype@ttynode:~# usermod -a -G dialout teletype

On MacOS

js-macOS:~ js$ ls -l /dev/cu.usbmodem*
crw-rw-rw-  1 root  wheel   18,  10 Sep  6 23:52 /dev/cu.usbmodem14501

On Windows

Third - Get some software and have fun

Now it's time to put your teletypes to good use. Most teleprinter software available should work with this interface since it's exposed as just a simple serial device. Check the Software section of this site for details. Also don't forget to check the configuration section down below to get to know your board better.

You can also roll your own software (if you do this, please let me know so I can link to your project). You can string together a few series of functions using your favorite programming or scripting language to manipulate the serial interface to your heart's content. Since the board shows up as a simple serial input/output device, it's fairly easy to send/receive text. See the setup section for further ideas.

How to Use - Special ASCII Control Codes

A later version of the firmware enables the use of special control character codes to control the board from the computer in a few useful ways:

Programmatically enter board configuration mode

This enables you to enter the board's configuration mode and programmatically execute configuration commands rather than having to manually press SW1 on the physical board. The main advantage to this is that custom software could make configuration changes on the fly depending on what the program was currently trying to do. For example, the ttyBash program leverages this functionality to temporarily disable crlf when printing ASCII/ITA2/RTTY art.

Different firmwares might have different customizations here, and you could customize the firmware yourself to set your own control character, but the known main two standards for this are:

• % - percent character - easy to echo to board, but could cause conflicts for ASCII machines
• 0x16 - SYN, Synchronous Idle - requires echoing the raw bytes to the board (e.g. printf "\x16" > /dev/ttyACM0), and should minimize conflicts with ASCII machines

If you're unsure which your firmware uses, simply try sending the characters to your board to see which, if either, your firmware utilizes.

Issue FIGS from computer

To be honest, this control character is rarely used, but if you ever find the need to send a FIGS from the computer to the loop, this is how.

Different firmwares might have different customizations here, and you could customize the firmware yourself to set your own control character, but the known main two standards for this are:

• { - left brace - easy to echo to board, but could cause conflicts with ASCII machines
• 0x1E - RS, Record Separator - requires echoing the raw bytes to the board (e.g. printf "\x1E" > /dev/ttyACM0), and should minimize conflicts with ASCII machines except in relatively rare circumstances when emulating old computers that actually used the Record Separator control character

Issue LTRS from computer

This is mainly used to ensure the teletype's shift is in sync with the board's since the teletype may have been left in FIGS when the current loop was turned off/board shut down. When the board powers on, it's by default in LTRS. To ensure they are in sync, this LTRS control character could be sent before printing anything else.

Different firmwares might have different customizations here, and you could customize the firmware yourself to set your own control character, but the known main two standards for this are:

• } - right brace - easy to echo to board, but could cause conflicts with ASCII machines
• 0x1F - US, Unit Separator - requires echoing the raw bytes to the board (e.g. printf "\x1F" > /dev/ttyACM0), and should minimize conflicts with ASCII machines except in relatively rare circumstances when emulating old computers that actually used the Unit Separator control character

How to Use - Configuration

The Volpe board has custom firmware installed that does some of the heavy lifting (Baudot to ASCII translation, &c). There are several functionalities that can be configured on the board itself.

To put the board into configuration mode, open up a screen session to the device, and then press the "SW1" button on the board. This suspends transmissions and instead opens up a command line interface on the serial port. You should see output like the following:

Commands available:
help, baud, table, [no]translate, [no]usos, [no]autocr, [no]showbreak, [no]8bit,
[no]autoprint, automsg, save, load, show, exit

CLI Commands

Print Current/Saved Configurations - show

cmd> show
Settings:                                  Cur     Saved
[no]translate   Translate ASCII/Baudot:    Y      Y
[no]crlf        CR or LF --> CR+LF:        Y      Y
[no]autocr      Send CRLF at end of line:  N      N
[no]usos        Unshift on space:          N      N
[no]showbreak   Display received breaks:   N      N
[no]8bit        8bit mode:                 N      N
table N         Translation table number:  0      0
baud N          Baud rate:                 45     45

Entering show will describe each available configuration and its current/saved setting. If the configuration has been set but not saved, the "Cur" and "Saved" columns will show a disparity. Setting the config without saving and then exiting will preserve the configuration until power is lost to the board (i.e. the computer shuts down or the board is disconnected).

Save Configurations - save

save simply saves any modified configurations. Remember-- if you exit without saving, changes will be lost the next time the board loses power.

Reload Saved Configs - load

Use load to reset the board to saved configurations. Alternatively, you could disconnect and reconnect the board to clear unsaved configs.

Exit CLI - exit

Enter exit to exit the configuration command line and go back to normal TX/RX operation.

Reset to Factory Defaults - eewipe

eewipe will revert ALL configurations back to factory defaults on the next restart (disconnect and reconnect the board). Like the *nix rm command, there is no confirmation prompt before actually executing, so only enter the command if you really mean to use it.

Configuration Options

Enable/Disable ITA2 ↔ ASCII Translation - translate

cmd> translate
Set to ASCII/Baudot translate mode.

cmd> notranslate
Set to passthru mode.

Default: translate

Enter translate to enable the board to automagically convert ASCII (8-bit encoding) received from the computer to ITA2 (5-bit encoding) on the current loop and vice versa.

Use notranslate to disable the board from converting ASCII/ITA2 to/from the loop. This should be used if either of the following are true:

• The software you intend to use on the computer already encodes for ITA2 and expects ITA2 encoding
• The machines on your current loop expect ASCII encoding

The translate functionality relies on lookup tables explained more in table and eewrite.

Enable/Disable Full CR/LF - crlf

cmd> crlf
CR or LF --> CRLF.

cmd> nocrlf
CR & LF independent.

Default: crlf

Use crlf to have the board automagically issue BOTH a carriage return and line feed to the loop when either one is received from the computer.

Use nocrlf to have no such functionality.

Enabling or disabling this functionality mostly depends on what your software expects. Modern operating systems handle CR/LF differently (for example, Windows sends both CR and LF automatically for a newline while *nix systems usually just send LF and Mac OS 9 and earlier used CR). On the other hand, some software written explicitly for teletypes may work the same way as a standard teletype-- that is, not send both a CR and LF automatically.

Worst case scenario is you keep auto crlf enabled, but your software already sends both automatically. The result would be that your physical teletypes would always add an extra space between lines. If this happens, simply run nocrlf.

Note that nocrlf is required for overstrike ASCII/ITA2/RTTY art (otherwise you'll get an LF and CR when you only wanted a CR).

Enable/Disable Auto CR/LF at EOL - autocr

cmd> autocr
Auto-CRLF at end of line.

cmd> noautocr
No Auto-CRLF at end of line.

Default: noautocr

Set autocr so that the board counts printable characters on a given line and automagically issues a carriage return and line feed to the loop once 70 characters are counted. 

Set noautocr so that the above functionality is disabled.

This can and will split words-- it does not intelligently break at the first space before the newline like the Bash command fold -s does. 

This must see at least one CR in order to work-- it starts counting after each CR.

Enable/Disable Auto LTRS on Space - usos

cmd> usos
Unshift-on-space enabled.

cmd> nousos
Unshift-on-space disabled.

Default: nousos

Use usos to cause a LTRS to be sent to the loop whenever a space is received.

Set nousos to have no such functionality.

This functionality automagically unshifts from FIGS to LTRS whenever a space is received, even if the teletype is not currently in FIGS. This can help keep shifts in sync. For example, if a teletype is turned off while still in FIGS, the board won't be aware of that the next time it's turned on and may print out FIGS characters when LTRS characters should be printing.

Enable/Disable BREAK Indicator - showbreak

cmd> showbreak
Show break indicator.

cmd> noshowbreak
Do not show break indicator.

Default: noshowbreak

Enter showbreak to have the text \[BREAK]\ echoed to the computer whenever there is a break in the loop circuit (i.e. the circuit is opened for longer than a few hundred milliseconds, or the time it takes to send a character or two).

Enter noshowbreak to disable this functionality.

You'd see this happen, for example, whenever the BREAK button is engaged on any teletype on the circuit or the loop power is turned off. This coincides with the green LED on the board going dark rather than being lit or blinking.

Set Loop Baud Rate - baud

cmd> baud 110
Baud rate set to 110 (divisor 757)

Default: 45.45

Enter baud <rate> where <rate> is the baud rate you wish to use on the current loop.

This configuration supports anything between 1 baud and 1200 baud. Attempting to set anything higher will result in error.

Note that several standard baud rates (45.45, 50, 75, 110) are programmed explicitly in the firmware using timings measured with a scope by this board's designer; anything outside the standards is calculated on the fly but should work fine. Actual maximum baud rate depends on various factors including current and inductance. The optoisolators on the board should be capable of achieving well above the 1200 baud firmware maximum.

This command accepts integers but will assume the common rates when entered. For example, entering baud 45 will set the rate to 45.45 in the background.

Enable/Disable ASCII on Loop - 8bit (experimental)

cmd> 8bit
8 bit mode for ascii machines.

cmd> no8bit
normal mode for 5-level machines.

Default: no8bit

Select 8bit to put the board into ASCII passthrough mode to work with ASCII teletypes such as the Model 33.

Use no8bit to set the board back into regular 5-bit mode for ITA2/Baudot-Murray machines.

As I have not used this functionality myself, I will simply quote Eric, the designer of these boards (original document here):

To try to use the board to talk to an ASCII machine like a Model 33, enter config mode and set “8bit” and “baud 110” - this

will also change various other options for you in order to hopefully make it compatible with 110 baud ASCII machines and

old computers. Since as far as I know most such application are full-duplex, you may need to remove the jumper between

the TX and RX terminal blocks and connect each block to its own loop. In this mode there is no character translation, and

the transmit and receive systems are switched to 8 bit instead of 5 bit. Also, since again as far as I know most ASCII

machines run on a 20mA rather than 60mA loop, you will be operating near the lower end of the range that the receiving

circuit can sense reliably, though it did work OK for me in testing. If you have problems receiving, slightly increasing the

loop current may help. If it falls below 15 mA it will almost certainly not work.

Note that later iterations of the board used an optoisolator that could sense much lower currents-- some as low as around 5mA.

Enable/Disable Autoprinted Message after BREAK - autoprint/automsg (experimental)

Default: noautoprint

This functionality enables you to have a short message (512 characters including non-printables) print out automatically whenever a BREAK is received (whenever the current loop is open for more than a few hundred milliseconds). This can even be done without a host computer connected (i.e. the board is simply connected to a phone charger for power only). This would be a handy feature to use when doing a minor demonstration where a host computer is not available or if you for some reason wanted to print out a specific message whenever a BREAK is received or the current loop turns back on after any period of being off.

Note that the functionality is finicky and should be disabled unless it's absolutely required.

1. To use, start by executing the command automsg in CLI mode; enter in the desired message:

   cmd> automsg
   enter up to 512 bytes. EOF at beginning of line to finish.
   > What hath God wrought?
   > EOF
   end of message.

2. Next enable showbreak:

   cmd> showbreak
   Show break indicator.

3. Finally, enable autoprint:

   cmd> autoprint
   Print saved text on break.

To disable, simply enter noautoprint and noshowbreak:

cmd> noautoprint
Do not print saved text on break.
cmd> noshowbreak
Do not show break indicator.

Configure Non-standard Character Encodings - table, eedump, eewrite

Default table selected: 0 (ITA2); tables 1 - 5 are blank by default

This functionality may be helpful for enabling the use of unusual encodings or doing something crazy such as modifying your ITA2/USTTY machine to a custom encoding for your own purposes. Yes, I called you crazy.

Select which translation table to use by entering table n, where n is the table number, 0 - 5.

See the hex contents of board nonvolatile memory (including tables) by executing eedump.

Use eewrite to modify the board's nonvolatile memory in hex-- you must modify only the tables' portion of memory.

As I have not used this functionality myself, I will give further details by simply quoting Eric, the board's creator, from his original instruction document here:

The default translation between ASCII and ITA-2 / Baudot is probably sufficient for most uses. The tables are read from

nonvolatile storage in real time as characters are sent and received. It is possible to modify the provided tables or to add up

to 5 additional tables, which can be selected using the “table” command. The default table is 0; additional user-added tables

start at 1. To add a new table, you will need to use the “eewrite” command to update values stored in nonvolatile memory at

the correct addresses.

Each table consists of 64 bytes; 32 bytes for LTRS followed by 32 bytes for FIGS. The same tables are used for both

“sending and receiving. When a character is received from the loop, that character’s offset is looked up in either the LTRS

or FIGS table, and the corresponding value found at that address is sent to the host as ASCII. So for instance if the shift state

is LTRS and the device receives 01010 (hex 0A, decimal 10), it will look at offset +10 from the beginning of the current

LTRS table, find the value 0x52, and send it to the host, which will see it as ASCII ‘R’. If the host sends the ASCII letter

‘Y’, the current LTRS table will be sequentially searched for a location whose value is 0x59 (‘Y’) and that location’s offset

(21) will be sent to the loop as 10101, where it will print as ‘Y’. The default table (0) begins in eeprom at offset 0x0080 for

LTRS and 0x00A0 for FIGS; table 1, if present, should start at 0x00C0 for LTRS and 0x00E0 for FIGS. When the “table”

configuration setting is set to something other than 0, the value is multipled by 64 and used as an offset from the beginning

of the first table. There’s no bounds checking so setting nonsense values is likely to produce nonsense data.

To create or modify a table, use “eewrite XXXX AA BB CC DD EE ….” XXXX is the start address, and must be exactly

four hex digits, padded with leading zeros. Subsequent arguments must be exactly two hex digits each, separated by exactly

one space, and will be written to eeprom locations starting at XXXX and increasing one at a time. Since the commandline

input buffer is small, you can only write 16 values at a time. The format is exactly the same as the output of “eedump”.

Note also that the “eewrite” command has no bounds or format checking and will allow you to corrupt all parts of

nonvolatile memory, including the baud rate and option settings starting at location 0. It can not, however, modify program

memory, so there is no risk of irrevocably damaging the device (see Factory Reset below.)

If you don’t like messing with hex, send me an email indicating what you want to change in the translation tables, and I’ll

send you lines of text you can cut and paste to the board in config mode.

Troubleshooting

Common problems and how to resolve them to be added here soon.

Firmware

Details about firmware, how to update it, and links to firmware for download will be added here soon.