DEV: Keyers: Iambic and Ultimatic

This page explains how electronic keyers work in detail: the timing engine inside the keyer, the important concept of “key memory” and the practical differences between Iambic A, Iambic B and Ultimatic modes. For an introduction to the different physical key types, see Straight Keys, Bugs, Paddles, Sounders and Keyers. You may also want to see an analysis of the efficiency of different key options, or experiment with a simulated keyer.

Inside the Keyer: Timing and the Element Cycle

The foundation of all electronic keyers is a single timing unit: the dit length. At 20 words per minute (WPM), one dit lasts 60 milliseconds. Everything else is a multiple of this:

ElementDuration
Dit1 × dit
Dah3 × dit
Gap between elements within a character1 × dit
Gap between characters3 × dit
Gap between words7 × dit

A keyer works through a repeating cycle when the paddle is active. It performs three distinct steps for each element it sends:

  1. Start the element. The keyer turns on the tone (and the transmitter, if connected) and sets a timer for the correct duration — one dit-length for a dit, three dit-lengths for a dah.
  2. Inter-element gap. The tone stops. The keyer sets a timer for one dit-length of silence, which is the minimum gap between elements within a character.

During steps 1 and 2, the keyer does not respond to new inputs from the key but (depending on the keyer type) it may internally note them in its memory. After the inter-element gap, the keyer performs a crucial third step:

  1. Check the key state (and potentially memory) state and decide what to send next.

It may then loop back to step 1, or it may be that there is nothing to send next, in which case the keyer adds further silence to complete the character or word spacing, and then stops. This repeating cycle of element–gap–decision is the heartbeat of every electronic keyer.

Key Memory

Imagine you are sending the letter K (dah–dit–dah). While the first dah is sounding you quickly touch the dit paddle and release it. By the time the dah finishes the dit paddle is no longer pressed — so should the keyer ignore that brief (strictly too early) touch?

In a good hardware keyer the answer is no: it uses a “key memory” or “paddle memory” system. The moment you touch the dit paddle, the keyer internally notes this — even while the dah is still sounding. When the dah finishes and the inter-element gap is over, the keyer checks its memory, finds the “dit was pressed” flag, and correctly sends the dit. Most keyers also have a “dah memory” that works the same way for the dah paddle.

In hardware keyers this memory is usually implemented with interrupt-driven latches: an electronic flag that is set the instant a paddle is touched and is only cleared at the start of the next element. This mechanism means that even a very brief paddle contact is never lost. The difference between keyer modes lies largely in which latches they maintain and under what circumstances they are set.

Single-Lever Keyers

Before we get to the more complex keyer types it is worth noting that some keys have only a single lever and that these may also be used with a keyer. Pushing the lever one way generates a sequence of perfectly spaced dits (as with the semi-automatic mechanical bug), and pushing it the other way generates a sequence of dahs. John Kaye (W6SRY) invented the “Ultimatic” single-lever keyer in 1953 (see p11) which also had dit and dah memories to permit/forgive less-precise keying.

The complexities of the other keyer modes arise from the fact that the operator can press both paddles simultaneously (“squeezing”) and the various options about how to interpret that signal.

Ultimatic Mode

The “Ultimatic” dual-lever keyer (which is generally what is meant now by “Ultimatic”) was invented by John Kaye (W6SRY) and described in QST magazine in 1955 (see p11) and also in the next edition (p36). Predating the iambic keyer concept, it builds on the Ultimatic single-lever keyer (and without squeezing the paddles, is identical in operation) but when the paddles are squeezed an Ultimatic keyer uses a “last paddle pressed wins” rule: the keyer repeats the element corresponding to whichever paddle was pressed most recently. It continues sending that element until the paddle is released or the other paddle is pressed.

Ultimatic has different efficiency trade-offs compared to iambic: it requires fewer paddle transfers for some letters (such as P and X) but more for others (such as C). Overall the difference across the full alphabet and digits is very small (see the Key Efficiency page for more data). Some operators prefer Ultimatic because it feels more like a natural extension of single-lever paddle operation, without the sometimes-unexpected behaviour of the iambic squeeze.

Basic Iambic Keyers

The most basic iambic keyer is a dual-lever keyer without any memory. It simply checks the paddle state at the end of each element. If just the dit is pressed, a dit is sent; if just the dah is pressed then a dah is sent; if both are pressed then it sends the opposite element to the one that was previously sent. Without any dit or dah memory, it requires the operator's timing to be quite precise.

Iambic A: The Curtis Mode

Iambic A is named after the behaviour of the Curtis 8044 chip, introduced in 1975 and used in a large proportion of commercially-produced keyers and radios ever since. Iambic A builds on the basic iambic concept and adds a dit memory and a dah memory. The memory is triggered by the paddle transitioning from unpressed to pressed during an element. If you hold the dit paddle down throughout the entire dah (from before it starts) the memory does not get set; only if you touch the dit paddle during the dah does it latch.

The practical consequence is that Iambic A stops cleanly when you release the paddles. When you release both paddles during a squeeze, the keyer finishes the element it is currently sending and then stops. There is a generous timing window: as long as you release before the end of the final element plus the following inter-element gap you will not accidentally generate an extra element. Some operators prefer Mode A because it stops cleanly when both paddles are released, making accidental extra elements less likely.

Iambic B: The Accu-Keyer Mode

Iambic B was introduced by WB4VVF’s Accu-keyer design. It also builds on the basic iambic concept and uses a dit memory and a dah memory. In contrast to Iambic A, both memories are set when the opposite paddle is pressed at any point during the current element, whether you are pressing it continuously from before the element started or just touching it mid-element.

The most noticeable effect of Iambic B is what happens when you release a squeeze. After sending alternating dits and dahs, if you release both paddles, the keyer automatically sends one more element opposite to the last one. This “bonus” element comes from the fact that the memory flag for the opposite element was set by the other paddle during the last element.

With the extra element being sent, the operator does not have to squeeze the paddles for so long. The trade-off is a narrower timing window. Releasing the paddles a fraction too late, or touching the opposite paddle by accident, can insert an unwanted extra element. New operators sometimes find Mode B generates characters they did not intend.

Comparing Modes: Sending the Letter C

The letter C (dah–dit–dah–dit) is a classic test for iambic keyers. To send it, an operator squeezes both paddles with the dah paddle first. The keyer sends: dah, dit, dah, dit.

In Ultimatic, the operator must press the dah paddle first, then tap the dit paddle during the dah element, then repeat the process for the second dah-dit. When the operator releases the paddles, the keyer stops immediately.

In Iambic A, the operator squeezes the paddles, closing the dah paddle first, then releases both paddles during the final dit. The keyer finishes that dit and stops.

In Iambic B, the operator releases both paddles during the second dah. The keyer finishes that dah and then automatically sends the final dit from memory, completing the C without any further paddle input.

References