Morse Keyer Redesign and Rebuild

Two inexpensive CMOS integrated circuits and a few transistors were sufficient to convert an old TTL automatic Morse keyer into a low-current, lightweight, battery-powered iambic Morse keyer. Over the last couple of years, the aging Accu-Keyer ceased functioning. This device was built over 30 years ago, based on the original TTL IC design published in the ARRL Handbook. The construction included a printed circuit board (PCB) created using nail polish as a resist and ferric chloride as an etchant. During the disassembly of the old keyer, the production method of the PCB was easily recognizable by the quality of the board. Although it was not aesthetically pleasing, the PCB could not be reused simply by replacing the defective ICs with new CMOS devices. At the time, the Accu-Keyer was one of the most popular designs, primarily utilizing TTL chips, which resulted in a current consumption of several hundred milliamps. This made battery operation impractical, and it was never attempted. However, there were moments when battery operation would have been advantageous. The keyer was not entirely satisfactory, primarily due to the power supply, which was homemade using a rewound transformer. As a financially constrained high school student, the power supply was crafted from a salvaged transformer, with the secondary rewound by hand to achieve the required 5VDC. Unfortunately, the transformer emitted a significant hum due to inadequate clamping of the laminations. Although dipping it in varnish could have mitigated this issue, it was never addressed. The hum was tolerable when enclosed in the casing, yet it was audible every time the keyer was powered on, prompting thoughts of eventual improvement. Despite the keyer's functionality, other projects took precedence. A few months ago, an attempt to use the keyer revealed that it had failed. After checking several chips and repairing an old TTL logic probe, it was discovered that nearly all seven chips in the original design had malfunctioned. While a few replacements were anticipated, the widespread failure of the ICs led to the abandonment of that idea. Keyers, or "Elbugs" as referred to in Europe, are devices utilized for sending Morse code. Most keyers employ a two-paddle key for operator input, where pressing either paddle toward the opposite paddle generates a series of either `dits` or `dahs`, depending on which paddle is activated. Unlike traditional manual Morse keys, keyers are engineered to produce nearly perfect Morse code, maintaining a ratio where `dahs` are equivalent to three `dits`, along with precise inter-symbol timing. Advanced keyers, known as iambic keyers, allow the insertion of a `dit` within a stream of `dahs`, or vice versa, facilitating the sending of sequences such as `dit-dah` or `dah-dit` with ease. To transmit an `a` (`dit-dah`), a single press of the paddles is sufficient, while sending a `c` (`dah-dit-dah-dit`) requires a slightly longer press. The primary goal of these keyers is to minimize the effort involved in manually sending Morse code. Although computerized keyboard keyers are available, they lack the portability of these devices and are less popular. Most modern keyers are based on microprocessors and incorporate memory functions to store standard messages, which can include `CQ` calling messages and routine phrases that frequently arise during communication, such as the operator’s name, location, and equipment details. Many also feature specialized auto-numbering messages for contest use. Some older TTL or CMOS designs also included memory capabilities, but these designs are less common.

The transformation of the traditional TTL-based Morse keyer into a modern CMOS version involves several key considerations in circuit design. The primary components include two CMOS ICs, which serve as the core logic elements, replacing the outdated TTL chips. The use of CMOS technology not only reduces power consumption significantly but also enhances the overall reliability of the keyer.

The schematic for the iambic Morse keyer would typically include the following sections:

1. **Power Supply Circuit**: A low-dropout voltage regulator can be employed to ensure a stable 5V output from a battery source. This minimizes the power loss and heat generation, making it suitable for battery operation.

2. **Microcontroller/CMOS Logic ICs**: The heart of the keyer, responsible for processing the paddle inputs and generating the appropriate Morse code output. This section may include a simple microcontroller or a combination of CMOS logic gates configured to handle the input signals from the paddles.

3. **Input Paddle Interface**: This section consists of two paddles connected to the input of the CMOS logic. The circuit design should ensure that pressing either paddle generates a clean signal, which can be interpreted by the logic ICs without bounce or noise.

4. **Output Stage**: The output stage typically consists of a transistor driver that amplifies the signal to drive the keying circuit of a transmitter or oscillator. This stage may also include additional filtering to ensure that the output signal is free from distortion.

5. **Optional Memory Circuit**: For those interested in adding memory functions, a small EEPROM or RAM chip can be integrated into the design. This allows for the storage of common messages, enhancing the functionality of the keyer.

6. **User Interface**: Simple LED indicators can be included to provide feedback on the status of the keyer, such as power on/off and keying activity.

Overall, the transformation of the keyer from TTL to CMOS not only revitalizes the device but also aligns it with modern electronic standards, providing a lightweight, efficient, and user-friendly Morse code transmission solution.Two cheap CMOS ICs and a few transistors was all that was required to rebuild my elderly TTL automatic morse keyer into a low current lightweight battery powered iambic morse keyer. Sometime over the past year or two, my elderly Accu-Keyer gave up the ghost and died. I built it more than 30 years ago (!) from the original TTL IC-based design published in the ARRL Handbook. It was an accurate copy of the original, right down to the printed circuit board which I made using nail polish as resist and ferric chloride etchant. As I was tearing the old keyer apart, I instantly recognised the PCB production method I`d used by the quality of the resulting PCB.

It was not very pretty, and I certainly could not reuse the PCB simply by replacing the dead ICs with new CMOS devices. In those days, the Accu-Keyer was the most popular design. Most of those keyers used TTL chips, and the current drain worked out to be a few hundred milliamps. Running it off batteries was hardly practical, and I never tried. But there were times when it would have been useful. In fact, I was never very happy with the keyer. The power supply was my biggest gripe, and my own fault. I made it using a rewound transformer. I was a poor high school student in those days, without much money to spend on the hobby. To get the right voltage for the power supply - I needed 5VDC - I found a transformer somewhere, pulled it apart, and rewound the secondary by hand.

The problem was that the darned transformer used to hum like crazy because I was unable to clamp up the laminations adequately. I guess I could have dipped it in varnish or something, but I never got around to it. The hum wasn`t too bad when it was all enclosed inside the little box. Even so, every time I turned it on, I would hear that hum, and I`d mutter to myself about doing something about the transformer `one of these days`.

But while the keyer was working and usable, I just couldn`t be bothered. There were too many other things of more interest to build. A few months ago, however, I went to use the keyer again (You can tell how much CW I do!) only to find the keyer had died. I checked out a number of the chips, fixing my old TTL logic probe in the process (The first dry joint in 20+ years), only to find that almost all of the seven chips used in the old design had up and died.

I was prepared to replace one or two, but the widespread deaths of ICs across the PCB made me forget that idea. Keyers, or "Elbugs" as the Europeans call them, are used to send Morse code. Most keyers use a two-paddle key for operator inputs. Pressing either paddle towards the opposite paddle results in the keyer sending a series of either `dits` or `dahs`, depending on which paddle is pressed.

Unlike typical manual morse keys, keyers are designed to send near-perfect code, with `dahs` equal in length to three `dits`, and with precise inter-symbol timing. The really neat thing about the more advanced versions of these keyers, called `iambic` keyers, is that these allow you to insert a `dit` in a stream of `dahs`, or vice-versa, or send a string of `dit-dah` or `dah-dit` characters.

To send an `a` (`dit-dah`) merely requires a single squeeze of the paddles. Sending a `c` (`dah-dit-dah-dit`) take no more effort - A single, slightly longer, squeeze does the trick. The objective of these keyers is to reduce the effort of sending Morse code manually. While computerized keyboard keyers also exist, they are not as portable as these keyers, and certainly nowhere near as popular.

Modern keyers are almost all microprocessor-based, and include memories to hold standard messages. These provide storage for `CQ` calling messages, and routine sentences which regularly occur during a call such as the operator`s name, location and equipment details. Most also add specialized auto-numbering messages for use in contests. Some older TTL or CMOS designs also supported memories, but these desi 🔗 External reference