Weekend Radio
Projects you can build - By: Mike Maynard, K4ICY

The K4ICY Minty-Kool Keyer   -   A 3-IC Fully-Iambic Electronic Keyer with Dot/Dash Memory and Progressive Weighting

As Presented in The Printed Circuit, Newsletter of the Tallahassee Amateur Radio Society (TARS):
     February 2015 - Page 18  Click Here for an index of Electronics Projects
     October 2015 - 

Revised September 2015...

       It’s true that commercially available keyers come as simple kits or encoded on tiny chips for only a just few bucks, but to get one of those you still have to order online or travel to a ham fest, and once you set up your brand-X keyer, there’s often some tricky menu navigation or programming involved.  What if keying was all you needed - why not just build your own using easy to obtain parts?

       I know many hams, since keyers became a reality in the 1940’s, have come up with cleaver schemes for automatically producing clean and evenly spaced Morse code, each employing various implementations from transistors to microcomputers, so could this ham have equal success?  I scoured the internet looking for an easy circuit to build and even tried designing variations of my own on paper - with no success - which would have used 555 timers and 4017 decade counters.  I thought of using an Arduino® or maybe programming some kind of stand-alone chip.  I knew what I wanted my circuit to do: it needed to make evenly and properly-spaced "dits" and "dahs" that could be sent in an "iambic" pattern (toggling them back and forth) if both paddles were squeezed.  It needed to obviously control my rig's key input too.  So what type of circuit should a builder like myself consider?


Minty Kool Keyer with the Depot Cootie


The Finished Minty Kool Keyer and Depot Key Ready for CW Play

       When I was a kid, integrated circuits (ICs) containing standard "discrete" logic building-blocks were the rage.  Logic, you know, is the language of computers – “1’s” and “0’s.”  My dad's generation embraced transistors but the basic electronics we learned up through the 1980’s were based on these primary components and practical arrangements. Kids these days, and I mean kids, are using fancier computer-like devices such as Arduinos and "shields" in their classrooms. They are bypassing basic electronics training and focusing more on programming and automation skills.

       So what device should a builder consider? Discrete logic and transistor components? A Microcontroller which would be a simple IC chip or development board I could just plug power up to?  I've seen a ham online "make an iambic keyer in five minutes" using an Arduino which is a credit card sized "Microcomputer."  Is there such thing as overkill, or perhaps would using discrete components be too complex?  To answer this, Ben Heckendorn of Element14’s The Ben Heck Show has a recent YouTube special on "Which Brain is Best for Your Project.”  just go to: https://www.youtube.com/watch?v=znUUhnLPGAk to check it out!  In fact, check out his other great videos!

       I saw schemes online that were quite complex indeed.  Some used demultiplexers and shift registers and others used a sea of logic, so let’s just say I was not encouraged.  Then I found it - a "Simple Keyer" design that was too easy-looking to be true.  Oh Hoekstra, PA2OHH, from the Netherlands has posted his version at: http://www.qsl.net/pa2ohh/iambic.htm  His is one of a few variations I've found of an original circuit crafted by Richard P. Halverson, W0ZHN and Ronald A. Stordahl, K0UXQ
for the April 1968 QST Magazine (ARRL) article entitled: "An Integrated-Circuit Electronic Keyer" - later, updated by Urs Hadorn, HB9ABO, on page 70 of Ham Radio Magazine back in January 1979.  Urs, HB9ABO, noted the keyer's lack of "Weighting" and Dot/Dash memory and Oh, PA2OHH, has made a few improvements, so I started with his schematic.

       The baton of progress never ceases to be passed in ham radio, and any circuit seems to be free game for other hams to improve upon.  Unabashed, I decided to "procure" the W0ZHN/K0UXQ/HB9ABO/
PA2OHH design for myself.  Immediately, I ran into problems, so I added a few of my own tweaks to improve stability and performance.  Building and improving the circuit on my prototype breadboard took a good week, but eventually it all came together.  I chose to go with this circuit for my keyer which uses discrete logic components – parts invented in the lat 60’s and early 70’s.  It's not an easy circuit to follow at first, but is very clever and ingenious in its simplicity.

       The standard Morse code spacing is based on one mark for "dits" and three for "dahs" with a single space in between.  The core of this circuit, developed by HB9ABO makes code beautifully - but not perfectly.  Weighting, as discussed in the last article, is not quite 1:1 but close enough for your ears.  [In HB9ABO's circuit] you can't set weighting which some hams require, [THIS WAS SOLVED AT A LATER TIME - PLEASE SEE BELOW.]  If you're one to gloss over technical babble then skip to the end of this article, but I'll try to describe this circuit here in detail:

Circuit Description:    Let’s take a look at the schematic. [SHOWN BELOW]  This is the largest circuit I've ever presented in Weekend Radio and takes a little experience on the builder's part, so I would consider this at least an "intermediate" level in project complexity.  It's okay not to have this figured out right away - it took me a few days to understand it, but it's "beauty through simplicity" becomes evident with some careful logic-path study.  Parts all together should be inexpensive ($15) since the ICs are around $1.50 each.


 Keyer Circuit on Breadboard

The Keyer Circuitry Being Tested on Prototyping Bread-Board

        The heart of this keyer is the Logic Oscillator which uses a NAND Gate Astable Multivibrator– to learn more please visit: http://www.electronics-tutorials.ws/sequential/seq_3.html  U1a; is a NAND logic gate - more specifically, this is one of four a "4011" CMOS NAND gates.  The "4000" series integrated circuits are more forgiving as far as voltage and current use goes, accepting anywhere from +5 to +15 volts, more or less depending on the type.  This NAND gate acts as a traffic cop.  When the input pin 2 receives a "high" signal (a binary "1",) which is a more positive voltage and is close or exactly in value to the power source value, and also if U1a also receives a high signal on pin 1, pin 3, the output will yield a "low" signal (a binary "0") which has no or very low voltage in respect to the power source.  As this is a NAND gate, if either of the inputs are low then the output will always be high – please reference the Truth Table.

       D1 through D7 are just "steering" diodes, meaning that current can only pass one way.  In this configuration they only will allow high signals to pass through their routes.     You'll notice that U1a's pin 2 is connected to ground via R8, a 100k.  What this does is allow pin 2 to "see" a more low signal if there's no voltage coming through any of the steering diodes.  So in effect, pin 2 is always low until one of the five routes presents a “high” signal.  C5 bypasses any unwanted AC, or actually, any abrupt changes to U1a's pin 2 due to "bouncing" from the paddle contacts.  It also helps prevent any of your rig's RF from influencing the oscillator.

       U1b is a NAND gate that has had its inputs tied together, therefore, any high on the inputs will output a low and vice versa, which makes this an inverter or "not" gate.  Its common practice to use a leftover gate on an IC in this configuration as a freebie inverter where needed.  U1a's pin 4 and U1b's pin 4 are linked together via a resistor/capacitor (RC) timing network in a type of Colpitts oscillator configuration.  Since pin 4 is in at an opposite state from pin 3, when one side has a voltage potential (source,) the other has more of a ground potential (sink.)  [Voltage potential, for charge and discharge will be routed through R10 and each respective part of R13 via R11 and R12 and their respective routing diodes; D8 and 9 (SEE PWM SCHEME BELOW)] charging C6 at an exact rate and when C6 is more fully charged and taking in less voltage, pin 1 of U1a will, at its threshold, "see" a high at pin 1.  Given that pin 2 is high, pin 3 will go high, pin 4 of U1b will go low and C6 will then discharge through R9.  The input at pin 1, through R9 at 100k, presents a much higher impedance than the resistor network; R10+R13 so the discharging of C6 will maintain a high signal for a certain length of time.  Because of the high-to-low or low-to-high threshold difference,  called "hysteresis" the resulting signal on pin 3 of U1a and pin 4 (opposite state of pin 4) of U1b is a nearly perfect square wave.  In this circuit, adjusting R10 should produce code elements in the range of 10 to 60 wpm, perfect for most hams.


NAND Gate Truth Table

      What happens to this perfect square wave signal?  U1d is the lifeguard on a killer slide at a water park, so to speak.  The guard allows each patron a specific instance to proceed so that each one makes it safely to the bottom with good timing.  Pin 11 or U1d is essentially the output signal source of the entire circuit, so keep this one in mind.  If pin 10, the output of U1c sits at any state for throughout time, when pin 12 of U1d receives the oscillator's "clock" signal, once checked against pin 13, pin 11 will either match or oppose the clock.  The result, if continued, will be a series of "dits," alternating single units for marks and spaces at the output.  U11's signal is ultimately routed through R14 to activate the two MOSFET solid-state switches (2N7000) which will complete the key circuit on your rig sending Morse code.  More on U1c's role in a bit…

K4ICY Minty-Kool Keyer Schematic

PDF Scematic Available: http://k4icy.com/Electronics/K4ICY_Minty-Kool_Keyer_02a.pdf

       Well, let’s step back a bit.  To tell U1a to allow for oscillation, otherwise it will stand still in waiting, we have to get a positive voltage signal through D1 and/or D2 – the paddle inputs.  With either a dual-paddle or single-paddle keyer connected to J1, Q1 and/or Q2, any standard PNP transistor (you garden variety 2N3906,) will go into full saturation, shunting positive current through the emitter/base junction and through R3 (or R5) 56k resistors to ground via your key's contacts.  Since it’s standard practice to wire keys with the common tied to ground, to get a high signal for our circuit to represent when a paddle is making contact, the PNP switch circuits essentially invert the key's ground potential.  R2 and R6 allow the transistors to be completely "shut off" when not in use, and C3/C4 help to both "debounce" the key contacts as they may often make multiple mini-contacts as eventual closure is made at the microscopic level.  Bouncing would introduce extra signals to the logic.  The capacitors also help shunt away RF introduced by the rig.


 J/K Flip Flop Truth Table (RS held low)

       Since Q1 and Q2 only produce positive potentials at their collectors, R4 and R7 provide a "low" for the logic to see when the transistors are not active.  So how do we get the "Dah's" and "iambic" action that keyers make?  Now we introduce another common piece of discrete logic called Flip Flops.  See this YouTube video for more detail: https://www.youtube.com/watch?v=bN02shtPWuI  More specifically, we’re using each of two "J/K" RS Flip Flop contained in the 4027 package and they have a specific functionality.  This Flip Flop has two outputs; "Q" and "Not-Q" (A "Not" is often shown a line above a letter signifying an inversion.) Q is the output and Not-Q is always at an opposite state of Q.  There are also master "Set" and "Reset" control inputs that can override the condition of the Flip Flop, but here, they are always tied to ground (or kept low.)  Here's how it works; the "J" and "K" inputs (initials named after the inventor: Jack Kilby, the Texas Instruments engineer that invented the integrated circuit in 1958) determine what the Q and subsequently Not-Q outputs are ONLY once a "Positive Edge-Trigger" has been signaled at the Clock input (“CLK” at U3b pin 13) In other words, the Flip Flop will only change state at Q when the input at CLK transitions from low to high.  Nothing will happen when it goes from high to low.  This can be a very useful feature in logic circuity.


       Take a look at the Truth Table: When J is low and K is also low, then on a positive edge-trigger of the clock, nothing will happen to the current state of Q - it will just stay put with no change.  The following looks straight forward if you think about it: If J is high and K is low, then at a clock signal Q will be high... obviously matching the input "J" to its left on the schematic diagram.  When J is high and K is low, then Q is low (Not-Q) being the same as K. Seems redundant at first glance, but it does mean at least J and K, if made high and low respectively, or in the reverse arrangement, then the output at Q can be made high or low to reflect the choice.  Finally, we call into play, the special feature of the Flip Flop, and that is, if we apply a high signal to BOTH J and K, whenever a positive-edge clock signal is applied, Q and Not-Q will swap states - or toggle!

       Let's take a look at U3b.  Pins 10 and 11 are tied to the paddle inputs and work independently representing any condition when one of the paddles on your key makes contact.  We can use this information to tell the Not-Q or U3b, pin 14, to change states based on whether just the "dit" paddle is in contact (low) or the "dah" paddle is in contact (high.)  The Flip Flop is at the same time told to change to the appropriate state because of a new clock signal sent from pin 11 of U1d which is itself initiated by the key signals to the oscillator.  With both paddles contacting, causing the J and K inputs to go high, a constant clock signal will cause the Flip Flop U3b to switch Not-Q back and forth between high and low... Ah ha - iambic action!

       "Iambic" you say?  We've got "dits" so what about the "dahs?"  Now let's visit U3a, the other Flip Flop contained in the 4027 package.  Its job is to help make the "dahs."  First it receives a clock signal (at U3a pin 3) from the oscillator that is always inverted from the signal at U1d pin 12.  Its "K" input is always kept at high, and the "J" input sample the Not-Q of U3b which means that Not-Q on U3a will either always sit at high when the "Dah" paddle is NOT pressed (U3b Not-Q is low) or will toggle whatever Not-Q's state is, as the clock signals trigger the Flip Flop.  Notice the components around U3a's pin 3: because Flip Flops can be very sensitive to voltage fluctuations and stray RF, U3a can act erratically if the voltage to its clock is too low or not stable.  C7 and 8 allows for some stabilization and elimination of RF at the clocks of U3a and U3b.

       What do we do with U3a's Not-Q signal (pin 2?)  The NAND gate U1c polls both U3b's Not-Q (pin 14) and U3a's Not-Q (pin 2) and sends a result control signal to the NAND U1d's pin 13.  If only the "dit" paddle is active, then U3b's Not-Q is low which means that U1c NAND will stay at a high output on its pin 10 because one of its input are low.  Consequently that means U1d will either have a "high, high" or "low, high" allowing it to match the oscillator clock with "dits" for an output.    With  U3b's  Not-Q  staying  low U3a's Not-Q output will always remain at a high state, meaning that U1c NAND would never have that "high, high" input required to change its output to low.  So there we have "dits" explained.

 Prototype Circuit (Component Side)

The Perforation-Board Populated

       So say the Not-Q of U3b is now at high because the "dah" paddle is contacted (and the "dit" paddle is not.)  Then the inputs of U1c are now "high, high."  Shouldn't that cause a low signal to be sent to pin 13 of U1d?  Well, on the same clock instance, U3a Flip Flop has highs at both J and K and its Not-Q will toggle; sending a low.  The states on the inputs of U1c are now reversed, but that really doesn't mean much on the first clock pulse.  The Morse "Dah" by standard is three times the length of a "dit."  If we look at this one from a “logic” perspective, a "Dah" would be sent sequentially as "1110."  To contrast, two "Dits" in succession would be "1010."  Ah. So if the second mark was kept high and all four steps were allowed to be produced, we would have a perfect Morse "Dah" element at the output of the keyer.  Consequently, U3a has become a "divide by 2" logic component when the "Dah" signal (U3b Not-Q) is active, so for every two clock signals of the oscillator applied to U3a, a single clock signal is outputted at Not-Q at half the speed.

       Once applied through U1c to U1d, taking into consideration the timing of the oscillator we are now mixing the "1010" of the oscillator clock with the "1100" of the Flip Flop to produce a "1110."  If you take a look at the Truth Table for the NAND gate you may now recognize a pattern: “0,0 – 1  /  0,1 – 1  /  1,0 – 1  /  and 1,1 = 0”.  Now regardless of whether or not the "dah" paddle line was tapped or held down, the keyer will continue to produce clock pulses until the "dah" element is completed.  This does this by simply routing the high signal of the output of U1d (pin 11) back to U1a via D7.  So there's our "Dah!"  I know this is all sounds really complicated but after some close study of the schematic, you too might appreciate its simplicity.

Prototype Circuit (Solder Side)

Traces Made From Blob-Bridges of Solder

       We can make "dits" now and we can make "dahs" too, so how do we alternate them to form an "iambic" sequence?  With both the "dit" and "dah" contacts active, the J and K inputs of U3b Flip Flop (pin 10 and 11) are now in Toggle mode.  Not-Q at pin 14 will only change states on a positive edge trigger of U1d's output.  So if U3b's Not-Q represents when a "dah" is to be produced, switching it off and on with each clock trigger will form "dits" then "dahs" and on and on... iambic action!  By the way, since the clock trigger at U3b pin 13 is essentially the output of the keyer, the iambic toggling will only occur AFTER a whole element has completed its sequence and the next one is just beginning.

       So we just discussed the core circuit created by HB9ABO.  Let's talk about the K4ICY contribution: You can build the above circuit just fine without the U2 NAND gate and associated four diodes, D3-6.  It will work just fine, but you will be enjoying code sending operation in what is called "Curtis A" mode.  Each time you contact a paddle the particular element called for will be produced, but if you want the next element to fall into place, say a “dit” immediately following a “dah” to make a "dahdit," if your "dit" paddle is contacted to soon before the "dah" is completed by the keyer, you may miss the “dit.”  So most hams find that using Mode A causes too many incomplete characters or missing elements, which is why Mode B is more popular.  Now in true "Curtis B" mode, which is incorrectly named and should actually be credited to WB4VVF’s “Accu-Keyer,” an element is always added to the end of your string of iambic elements that is opposite of the first element you contacted, such as "dih-dah-dit," or "dah-dih-dah."  (please visit: http://www.palm-radio.de/pdf/IambicPaddleModeAorBfunction-1.pdf for a more concise description.)


       Though convenient, this can get tricky.  Most modern keyers, whether on chip or featured on a rig, uses a more simplified form simple known just as "Mode B."  In the simplified Mode B, the keyer simply polls the opposite paddle of the one the keyer is in the middle of producing an element for basically to see if something is being asked for while it’s busy.  It then inserts the opposite element after the current one is done - or just a basic memory latch.  I was really not happy with the Mode A keying the 2-IC version of this circuit produced so I added an extra NAND gate and a few steering diodes.  I simply poll the outputs of the U3b Flip Flop and the incoming paddle contacts.  With the U2b NAND, if pin 5 sees a high on the Q of U3b Flip Flop and pin 6 sees that the "Dah" paddle is active, then it goes low at the U2b pin 4 output which is inverted by U2a.  This means that if the Flip Flop is commanding "dits" and a "dah" is asked for, then pin 3 of U2a is high.  This high signal is sent to the oscillator clock to keep it going until its associated counter element is completed.  The high signal also keeps a high on the "dah" line of the Flip Flop so that the circuit essentially latches and all you have to do is quickly tap the "dah" paddle to ask for a "dah" to be made after the keyer is finished making a "dit."  This is essentially a “bit” of memory.  U2c and U2d together do the same thing except for opposite conditions.  With the addition of this feature, this "simple" keyer is now on par with the basic function of commercial keyers!

       Finally, notice the configuration of the two 2N7000 MOSFETS on the keyer’s output; they both have their Gates attached to the output line and the rig’s key line connects to the Drain of each MOSFET. A high from the output (pin 11) of U1d (through current resistor R14) will cause the MOSFETS to pass current from their Drain pins to their Source pins at ground potential.  How can a DC signal pass in both directions through a MOSFET, doesn’t it act as a rectifier?  Well, often not shown in the schematic is a bypass diode built in which shunts backwards flowing current from the Source pin to the Drain pin.  This helps protect the MOSFET from transient reverse currents that would quickly destroy it.  We use this feature here to allow a path for the rig's key circuit to complete.

       There are a few added advantages from using MOSFETS in this configuration over Bi-polar Junction (standard) transistors or relays.  Since the Gates of the MOSFETS are more voltage driven, the current needed to pass current through the Drain to Source is extremely minimal.  There is better RF immunity here as there is a nearly direct path through the MOSFETS.  These MOSFETS are cheap and common to source, you can find them used in many QRP kits and they can handle up to 60 volts!  And finally, polarity is not an issue as it would be with a transistor, so if your radio keys some kind of AC waveform to activate its transmitter circuit then this should be able to pass it through.

       All that's remaining in this circuit are a few little components to deal with the power source.  Since the CMOS logic components can typically handle anything from +5 to +15 volts, and sometimes more or less depending on the type, you can derive a power source from USB, a nine-volt battery or even your 13.8 volt ham shack power supply.  R1, a 100 ohm resistor, helps to mitigate any voltage spikes that may be present on the line.  You should also consider adding a diode such as a 1N4001 to "goof proof" the polarity.  Just one reversely connected battery will instantly send your CMOS IC's to Heaven.  C1 is an electrolytic capacitor that will handle any additional broad voltage swings and C2 will help keep stray RF from affecting the CMOS ICs.  As a note, C6 in the oscillator should probably be a nicer film-type mica or polyester capacitor or "NPO" type if a ceramic type has to be used as capacitance drift may cause performance issues with the oscillator due to leakage.  Keep the lead length short between R9 and U1a pin 1 so that RF is less likely to be introduced into the oscillator via the NAND gate.

Thoughts on Construction:
   If you are new to working with logic you may wish to first build this circuit on a temporary plug-in prototyping bread board.  In fact I would suggest doing that anyways.  There are often performance variations in components especially between manufacturers and types and even between different model spec variations of the same CMOS logic.  The easiest way to permanently construct this keyer may be use the "dead bug" or Manhattan style on copper clad board. This will provide a lot of RF immunity as well as allowing you to space out the components as comfortable as you wish.  I populated my circuit on a through-hole prototyping perf-board with very minimal spacing.  I have my own preferred method that uses solder blob bridges on the bottom with thin-wire jumpers across the top.  Parts are often logically arranged, but I put no thought into where everything goes at first - making it up as I go along.  Sometimes it's good to just worry about ground connections all meeting on the solder side first.  Just remember to leave some holes for the pin-outs on the ICs.  My "housing" solution was to mount the board, batteries and phone-plug connectors in an Altoids® mint tin - the choice of QRP homebrewers!  If the final board is no larger than 2” x 2” it will fit.  And since I have experience doing this, I advise the rest of you to consider just building the board first and then finding a good container.


 Keyer Housed in Mint Tin

Housed In The Homebrewer’s Choice

       Using a metal container is preferred to combat RF, but that still doesn't mean that RF from an imperfect antenna system isn't going to wreak havoc on your keyer or worse, cause damage to the components.  There are other solutions that can be employed such as key-line isolation or grounding and shielding with toroids but this is out of the scope of this lessen, so let’s chalk up RF mitigation to the trials of homebrewing.  As you might be able to see in the pic, I layer down a padding of electrical tape on the bottom to keep the board traces from contacting the metal surface.  I usually place the nine-volt on one side and the connectors on the other, and in this case I have left space available for a mini-panel-mount potentiometer, which I'll have to special order.  For now I have a miniature 1M pot mounted to the board which I have to set with a screwdriver.

       Other things to mention: The power consumption on this keyer is LOW! No, really! When in use, the keyer will only draw 0.5 miliamps, and when not in use does not even register on my multimeter!  Using MOSFETS on the output helps since they are voltage-controlled devices and the CMOS ICs, according to their specs, only draws a mere 50 nanowatts each.  If you were supplying LED’s the current would jump drastically but so I suggest not anything else fancy to it and if you're using a nine-volt battery, use a "heavy duty" type meant for low-drain devices.  You should not have to install a power switch and it should last a year for sure.  An Alkaline battery will probably leak if left in with that little of current being drained.  When handling the components, take necessary precautions as the CMOS ICs and MOSFETs are extremely sensitive to static discharge and reverse polarity.

       Room for improvement: A predecessor of this keyer has been coined "A Simple Keyer" because of its Spartan operation. It lacked basic features taken for granted on modern versions internal to modern rigs such as Dot/Dash Memory which allows for leeway from human error by making the timing of your finger movements less critical to keyer operation, and it lacked "weighting" (the relative timing between an element's mark and space) which is important to many hams dealing with older rigs as well as the increased need for more staccotic elements is crucial to faster sending speed. Yet, the original circuit core used three ICs as well!  The simpler "Simple Keyer" iteration of this keyer's core design uses only two ICs - It's elegant, but you get what you pay for.  Many hams have trouble sending in "Mode-A."  There are countless keyer circuit devised over the years that employ memory for canned macros and allow for the adjustment of each elements as well as weighting.  And some of these circuits use way more logic than is required to do the job.  But with all that said, Amateur Radio homebrewing is all about improvising and innovation.  Each ham is free to do what they desire in the name of fun and education.  If I had any more improvements to make to this simple circuit it would be to add control for [full] element weighting, [SEE BELOW for implementation] element scaling (dot/dash ratio) and maybe an addition of couple of other modes such as "Ultimatic" and "Bug."

       So there are 1-chip keyers out there to be had for a few bucks, why not just use one of those in your QRP rig?  That's obvious to many hams!  If you're going to homebrew your own QRP rig or build one from a kit, then why not homebrew your own accessories.  How many hams can say that they built a functional "Mode B" iambic keyer from off-the-shelf components that just so happens to fit in an Altoids® mint tin?  BOOM!  A Minty-Kool Keyer.  It's a 'work in progress' and I still have testing to do on different rigs, but at least I know I don't have to rely on one ordered online existing only as a program on some mystery chip.

Weight Control with the Mints Diet  -  Adding Element Weighting to the K4ICY Minty-Kool Keyer

     A Forward to the Weekend Radio article printed in The Printed Circuit, February 2015 - Published October 2015

       It never fails!  The solution to a problem often only comes to mind AFTER you publish the article it was concerned with - oh well.  The K4ICY Minty-Kool Keyer was my take at a 47 year old circuit, and though, many hams had tried their hands at it over the years, I not only wanted to perfect the keyer circuit but stuff it into a mint tin as well.  There were always two features often noted as being left out when other hams built their versions; dot and dash memory and “weighting.”  Dot and Dash memory was my first improvement, and now I provide a solution for element weighting.  Confused?  Just check out my previous article in the February 2015 Printed Circuit: http://k4tlh.net/wp-content/uploads/2011/11/TARS_Newsletter_2015_February.pdf#page=18

       Weighting is the relationship in time-duration (or ratio) between a single Morse ‘dit’ element (called a “bit” or a “mark”) and its associated silence (called a “space”) following the element.  This attribute can affect not only the way the code sounds but the ease at which it can be copied, as well as its performance as sent via transmitter.  Well-sent code is said to have 1:1 weighting where each ‘dit’ is equal to 1 bit, each inter-element space is equal to 1 bit as well, a ‘dah’ holds out for three bits with three bits for inter-letter spacing and seven bits between words.  The word “PARIS” is said to contain 50 bits and represents an “average” English word.

       1:1 code sounds proper at slow speeds but ramp up the pace, to say, over 40 WPM and (most) human ears begin to have trouble deciphering code.  It would then not be surprising to know that many seasoned CW ops prefer a “light” code weight where the marks are shorter than the spaces yielding a staccato quality to the sound, making fast code actually easier to copy.  To learn more about code weighting, check out this YouTube video: https://www.youtube.com/watch?v=oidlVnChVAQ  Take note that ‘light’-weighted slow-code doesn’t sound particularly very well to most ears – a reprieve to a limitation we’ll discuss later.

       An issue that also arises with faster code has to do with the way that a transmitter sends the code itself.  If you cut a CW transmitter on and off instantly according to when your key contacts close, you would most likely be producing a lot of clipped and hard-terminated waves, or essentially square waves.  Square waves contain harmonics of course and a CW transmission sent in this manner would splatter all up and down the band, producing clicks and pops too.  To avoid this, your transmitter eases the CW signal up and down in power-amplitude making sure that only pure sine waves are produced completely.  So this ‘envelope’ encapsulating the CW signal has pre-determined rise and decay ramps taking a certain amount of time to complete.  As the sender’s code speed increases, the decay time may reach and surpass the amount of space time left in between elements until ultimately, the code becomes muddled.  Shortening the code element mark time gives more leeway to the CW envelope so that distinguishable code can be still sent.

Morse Code Weighting Duty Cycle   An example of Morse code Weighting Duty-Cycle

       Implementation of weighting was a tricky task indeed; how would I change the ratio of mark and space timing, otherwise known as the ‘duty cycle’, while giving the operator a good speed range to choose from?  I thought of three solutions, and not surprising, my first thought ended up being the best.  One solution was to use a NE555 timer IC to add a starting delay to the output element, clipping the signal but this would have been hard to tune across the chosen speed range and would have introduced a sluggish feel to keying.  Another was to speed up the logic oscillator by a factor of 10 using a 4017 Decade Counter to break down the ratio in 10 precise steps.  I still like this idea, but each would have added more ICs.  Ultimately I came to my senses (after publishing the article of course) and chose to apply a Pulse-Width Modulation scheme to the logic oscillator.  For a description and example of PWM check out my article in the May 2013 Printed Circuit:

       Referring to the schematic, take note of the logic oscillator circuit (center-top) comprised of (4011) U1a, U1b, R9-12 and C6; you can see that this section has been revised from the schematic in my original article.  This is a basic NAND gate logic oscillator circuit where a bi-polarity capacitor is charged via a resistor(s) in an RC circuit which upon charging and discharging at a rate determined by the values of R and C cause the gates to flip high/low states generating a square wave.  If the charging resistor(s) was one value (as arranged in the original circuit) the timing at U1’s pin 3 (and inverted at pin 4) should yield equal timing of both mark and space.

       A PWM scheme is used in this schematic to present two separate timings, one for charge and the other for discharge.  Routing diodes D8 and 9 present separate paths for capacitor (C6) to charge at a rate determined by one resistance value and then discharge at another.  Notice the value of R11 (22k) compared to R12 (33k) as they form a representative ratio.  They join into the separate sides of R13, a 100k potentiometer.  R11 determines mark timing in this circuit and R12 governs the space.  R13 gives you the ability to adjust the ratio amount of charge timing to determine weighting.  Here, I’ve slanted the tendency for “light” weighting.  R10, as before, gives you a dynamic code speed range between 6 and 60 WPM.  You should try to use a reverse log taper potentiometer or it will seem like all of your control will be on the slow code end, but the choice of taper is not crucial to operation.  Essentially, the whole network of resistors represents a combined set of resistance for generating a complete PWM mark+space timing cycle.

       Here’s the catch!  When the keyer is generating code at the insane speed of 60 WPM, R10 would be set to zero Ohms and C6 only has to charge through R11 + part of R13 and discharge through the other part of R13 + R12 (I’m not sure which was really charge and discharge.)  The difference in charge time is drastic between these two paths at such low resistance, potentially a 6:1 ratio!  You can really get some super-light weighting with that.  But, at the slow end of the scale with R10 turned to a max of 1 mega-Ohms, R11-13 appear relatively small!  In fact, you get only a resistance ratio of 1.1:1, so no discernible weighting there for sure.  Any good marketing person will make lemonade from lemons simply by adding a positive descriptor – I chose “progressive!”  This is a case where an inadequacy turned out to be an okay thing because we really only need the lighter weighting at the higher speeds and not at the slower speeds.  In fact this actually works out, as in my build I’ve omitted R13 and tied the ends of two fixed values together that gives me a good 4:1 ratio at 60 WPM, 2:1 at 30 WPM and 1.5:1 at 20 WPM.  I derived these numbers from a simple QB64 BASIC program I wrote which was roughly backed up by testing.  For this result, omit R13 and make R11 22k and R12 a 33k + 100k (in series.)

       Now if you’re building this keyer, you could easily plug in your own resistance values or even a resistor network configuration to get a good weighting ratio at the larger 1 M-ohms area.  To figure the charge+discharge times for yourself (And you Extras should know this,) multiply the Capacitance times the Resistance… well, decimal places will kill ya:  Capacitance in μF  x  Resistance in Kilo-Ohms  =  Time in milliseconds.  Multiply by 0.001 to convert that to Seconds.  To find the “universally accepted” WPM, add your charge and discharge times together and divide by two (for an average,) then divide that into 1.2 for your WPM speed.  The 1.2 has something to do with the 50 bits in “PARIS,” as in milliseconds, figured into a minute.  For example: if we find 1 M-ohms (1,000k) for our resistance (averaged for both directions) and find the total charge/discharge time for the 0.22 μF cap we get 220 msec. (1,000 x 0.22 x 0.001 = 0.22 seconds)  for a combined mark and space ‘dit’ element cycle.  To find for the speed: (1.2 ÷ 0.22 seconds = 5.4 WPM)

       So the K4ICY Minty-Kool Keyer is “nearly” perfect.  I was able to make the changes to my mint tin build and confirmed my results with a program called SoundForge on my PC.  Audio was sampled via Yaesu FT-857d (into laptop) reading ultra-low-level RF leaked from my Kenwood TS-130SE fed into a 50 Ohm dummy load at a very low wattage.  I was able to analyze the waveforms and measure the millisecond timing of code produced through the keyer’s available speed-adjustment range.  The standard niceties of a keyer are there, minus canned messages:  adjustable ‘iambic’ ‘squeeze’-keying, dot and dash memories, progressive weighting and rig control.

       Why seek to improve an obsolete design with half-a-century-old technology when so many simpler and novel methods exist today?  Nearly all modern rigs come with onboard CW keyeing and what modern ham wouldn’t rather dabble in the newest microprocessor or microcomputer?  Sure, you should try everything once, so build an Arduino keyer too sometime in your ham career
– check this out:  http://blog.radioartisan.com/arduino-cw-keyer/
but be prepared to learn some programming.  Well, even the single-IC Curtis chip existed in 1969 (http://namham.phpbb8.de/general-topics-f18/history-the-curtis-keyer-t50.html) with the EK-39 but the reason for “rolling your own” was the same then as it is now: the draw to building a piece of equipment from more fundamental parts boils down to the homebrewer’s sense of ‘roughing it’ – bringing a wonder to life with your bare hands – especially a device you understand the inner-workings of.  Now, more than ever, there is a modern movement amongst hams in homebrewing or kit-building their own gear, especially gear you can take on the trail.

       I cannot take complete credit for The K4ICY Minty-Kool Keyer.  The keyer’s genesis was conceived by Richard P. Halverson, W0ZHN, and Ronald A. Stordahl, K0UXQ, for their article “An Integrated-Circuit Electronic Keyer,” [pg. 22, QST, April, 1968].  It was also a 3-IC circuit and had dot/dash generation using a single-lever paddle, but no iambic (“squeeze”) keying.  Urs Hadorn, HB9ABO of Oberglatt, Switzerland modified the keyer for his article “Simple CMOS Keyer,” [pg. 70, Ham Radio Magazine, January 1979.]  His circuit was just about the same as the one presented in the QST article but with only slight improvement, however he reduced the chip count to two, provided several rig-interfacing schemes and actually built a few keys to go with it.

       Three years later, Oh Hoekstra, PA2OHH, from the Netherlands made his first “Simple Iambic Keyer” circuit and in 1999 posted a revised model online at: http://www.qsl.net/pa2ohh/iambic.htm.  Not only did he revise the HB9ABO circuit, adding iambic dot/dash coordination which allowed for use of a dual-lever paddle, but improved the key and rig interfacing.  Even with his offer, there were still some features missing that all the builders mentioned here made note of; features that proficient CW operators often desire for comfortable sending: dot/dash memory and weighting.  Dot/Dash memory allows for extra opposite elements to be generated upon command even if the keyer was busy; so if you are in the middle of making a dash, tapping on the dot paddle would put a dot in queue to be made once the dash was completed.  This makes for sure and comfortable ‘squeeze’-keying.  Weighting was the obvious additional creature comfort.

Feel free to ask me questions or submit comments.

73! DE Mike, K4ICY k4icy@arrl.net

Edited: 09/15/15
©2016 Copyright - Michael A. Maynard