
  



  Introduction for Non-Hams:

  CW is what ham radio operators call Morse Code.  A keyer is an electronic
  device that lets a CW operator send code faster and better than the old
  fashioned mechanical keys.  Essentially, the operator has a pair of levers
  (called paddles) between his thumb and forefinger.  The levers operate
  switch contacts.  Pressing the thumb operated lever produces a continuous
  stream of dots.  Pressing the index finger operated lever (the dash paddle)
  produces a continuous stream of dashes.  Squeezing both paddles together in
  a pinching type of action produces alternating dots and dashes.  You can
  try out the keyer using a joystick (except you can't squeeze both paddles
  this way).


                               The WA5BDU Keyer


  Working CW in the computer age, I've noticed something:  Real CW men don't
  use keyboard senders.  They do own them - I have one that I built, plus a
  couple of commercial programs for my computer.  But I go back to my paddle.

  The purpose of this programming project was to create a computer CW
  generating program which would:

  1. Allow the CW Op to use his paddle.  (Hence, it's primarily a keyer, not
     a CW keyboard.)
  2. Allow a degree of customized and personal ``feel'' and "sound.''
  3. Give the option of keyboard generated code, with the special features
     only a computer keyer is capable of.

  The keyer's features include adjustable dot, dash, word, and character
  ratios, and sophisticated stored message (memory) capabilities.  Features
  unique to computer keyers include a type-ahead 256 character transmit
  buffer, a real-time ``message transmitted'' line, and a memo pad screen
  area for taking notes while receiving.  (I can never find a pencil or paper
  after I start a QSO.)

  The design philosophy was to make commands and controls either unnecessary
  or easy to remember and enter.  For instance, there's no command to toggle
  from ``keyboard'' to ``paddle'' mode.  Just start sending (or typing).

  A unique feature (since seen in other keyers) allows you to give commands
  (speed change, etc.) directly from the paddle, in Morse.  A special
  ``command'' character causes the keyer to interpret following characters as
  a command sequence.

  Text sent with the paddle is interpreted and put to the screen, so you can
  keep track of where you are in a sentence, and so your non-CW literate
  guests can see that you're really saying something.







                             Detailed Description

  Interfacing:

  The paddle and keyer output are wired from joystick jack #2.  (Plug in a
  joystick to try it out.)  The pin-out looks like this:

            1 2 3 4 5
             6 7 8 9

  Pin 1:   Keyer Output
  Pin 2:   Command Button
  Pin 3:   Dash Contact
  Pin 4:   Dot Contact
  Pin 8:   Common

  Also, joystick jack #1 pins 1 thru 4 are additional alternating normal and
  inverted keyer outputs.

  Screen Layout:

  The screen has three main windows and two one-line windows.  From the top,
  they are:

  1. Status Window: Parameters such as speed, tone, ratio, and other options
     are shown here.
  2. Command Line: This line lights up to show command inputs, prompts, and
     statuses.
  3. The Middle Window is normal the Memo Pad area.  In the message edit
     mode, messages are composed here.
  4. Transmit Line: Text is scrolled across this line as it is transmitted,
     whether from the paddle, type ahead buffer, or a stored message.
  5. Transmit Buffer: This is the type-ahead transmit buffer area.

  Operation:

  Most keyer functions are programmed by entering a COMMAND sequence,
  followed by parameters, if needed. There are four ways to enter the command
  mode:

  1. Press OPTION
  2. Send ( by paddle ) the COMMAND character, which is identical to the
     Morse WAIT character (.-...).
  3. Connect the joystick port COMMAND line to common.  (This enables you to
     mount a pushbutton at the paddle, so you don't have to reach over to the
     console or send the COMMAND character to enter the COMMAND mode.)  Pull
     back on the joystick to demonstrate this method.
  4. Send the asterisk (*) character. This method has the special function of
     allowing you to embed command sequences within stored messages.

  The Command Line will light red and request input when you enter the
  command mode. Commands consist of two letters plus data as required.
  There's no action needed to toggle out of the COMMAND mode, the program






  senses when the command is ended or when an invalid character is sent and
  returns to normal mode. So if you enter the COMMAND mode in error, just
  send an invalid character.  I've reserved "E" for this, since it's an
  easy single dot from the paddle. From the keyboard, the Escape key works
  and is probably the intuitive key to hit.

  Now, a description of the commands:

  SP:  Speed.  Enter (from keyboard or paddle) up to 5 digits, including
  decimal.  Yes, fractional speeds, such as 7.96 WPM, are allowed.  Per Morse
  convention, the program will accept the letter ``R'' as a decimal point.
  The command terminates when 5 characters are sent, or when an invalid
  character is sent, such as in "20X".

  RT:  Ratio, doT:  Input the ratio in the same way as the speed was done.
  Adjusting ratios to your liking allows you to customize your sound and keep
  from sounding like a computer. Normally a dot and a space are the same
  duration.  The ratio specifies how long the particular element is with
  respect to a space length.

  RH:  Ratio, dasH:  Same as above for dash ratio.

  SW:  Word Space:  Specifies the duration of the space between words
  (entered with the space bar and applicable only to keyboard sending). This
  space is given in 1/2 dot units, for finer control.  Adjusting the Word
  Space and Character Space allows setting up the keyer for ``
                                                                Farnsworth''
  type sending. This is a type of sending used in code practice in which
  slower speeds are achieved by sending characters at a fast rate, but
  increasing the time between words and between characters. Note that
  altering the Word and Character spacings and dot and dash ratios throws off
  the speed indication.

  SC:  Character Space:  Same as above, except specifies the duration of time
  between characters in 1/2 dot units.

  CS:  Console Speaker: - if you have an `800' or `400', the side tone will
  be via the built in speaker in addition to the TV/Monitor's sound.  Send CS
  again to turn the console speaker off.

  VO:  Video Off:  This turns off the screen, making the CS tone a bit less
  raspy.  (The idea of this and the above command is that you may want to use
  the keyer without a monitor.  I think it can be operated blind fairly
  well.)

  KD:  Key Down:  This is the ``TUNE'' command. It locks the key down.  Any
  action (keyboard, paddle, or console button) releases it.

  OA:  ON/OFF Air:  Determines whither the transmitter will actually be keyed
  when the keyer generates code.  Now you can play with the keyer without
  needing to put the rig in STANDBY.

  IK:  Inverse Keying:  Inverts the keying output logic.  If you design your
  interface with inverted logic, you can correct it via this software
  command. Normal logic is output pin HIGH for key down.







  TO:  Tone:  Input the desired monitor tone frequency.  (Affects the
  monitor/TV speaker output only.)

  OM:  This command opens a message for creation or editing.  Messages are
  labeled A thru Z.  To exit the Message Edit mode, press ESCAPE, or send an
  End-Of-Message (.-----) code from the paddle.  True confession:  The
  editing functions are limited.  You can type-over, back-space, or clear a
  message. Often clearing and retyping a message is the easiest way to edit.

  BE:  Buffer Enable/Disable:  When enabled, the buffer is sent until empty.
  It starts when you start typing.  When disabled, you can type into the
  buffer and send it later.  The TAB key duplicates this function for easier
  control. Hitting the paddle also stops sending of the buffer (based on the
  assumption that you want to insert something from the paddle), but sending
  starts again when you press a key. (Use the space bar if you just want to
  get buffer sending started again.)

  BC:  Buffer Clear:  Empties the transmit buffer.  Shift-Clear may be used
  from the keyboard.  Every memory keyer user has stories to tell about
  accidentally starting up a message and being unable to stop it.  Here's
  how!

  MA thru MZ:  Transmits message memory A thru Z.  This is the normal way of
  sending a stored message from the paddle.  It's assumed you want it sent
  NOW, so any holding text in the type ahead buffer is cleared out and the
  message is sent instead. From the keyboard, there is another, easier,
  method of sending a message. Just type in the message letter in inverse
  video.  Recall that inverse video is selected by pressing the "Atari''
  key, which on the old 800/400 is just left of the right SHIFT key and on
  the XL is just to the right of it.  Inverse video is automatically
  deselected after you type the message ID.  With this method, buffer text is
  NOT cleared, so messages can be put in the queue with other text.  When the
  sender encounters the inverse letter embedded in the text, it sends the
  message, then picks up with any following text.

  HS:  Help Screen:  A short description of all commands and interfacing
  information is scrolled thru the middle window.  Press START for the next
  page or SELECT to cancel.

  HP:  Help to Printer:  The help text described above is dumped to the
  printer.

  PS:  Parameter Save:  All parameters of the current setup (speed, tone,
  ratios, etc., are saved to a disk file.

  PL:  Parameter Load:  Loads the setup saved by PS into the keyer.  Note
  that if a file called AUTOPARA.KEY exists, it will automatically load when
  the program starts.  This allows you to easily customize the keyer to your
  liking and have it start that way every time.

  TS:  Textfile Save:  Saves all currently existing stored messages in a disk
  file.






  TL:  Textfile Load:  Loads the messages saved by the TS command.  Note that
  if a file called AUTOTEXT.KEY exists, it will automatically load when the
  program starts.

  Other Information:

  The SELECT button toggles the keyboard between the transmit window and the
  memo pad window.  In the Memo Pad mode, you can take notes with no effect
  on the keyer.







  More on Messages:

  Messages can call other messages, up to eight deep.  If you program an
  infinite loop (A calls A, or A calls B and B calls A, etc.), the program
  recognizes it (to prevent an internal stack overflow) and tell you.  The
  loop will continue indefinitely until any operator action (keyboard,
  paddle, button) occurs.  You can use an infinite loop to program a
  repeating CQ, for instance.

  Commands can be embedded within messages.  Just put in an asterisk followed
  by the command information.  This allows programming quick one-key setup
  changes.  For instance you could make messages F and S mean fast and slow
  speed.  So F would contain *SP30 and S would contain *SP15.  And just for
  fun, you can program simulated QSO's where two guys with different speed,
  sending characteristics (ratios) and pitch are talking to each other.

  Sometimes it's desirable to pause a message and insert text.  This is
  possible if you insert using the paddle, but not the keyboard.  Just tap
  the paddle to pause the message, send the inserted text, then hit the space
  bar to make the message text resume.

  More on interfacing:

  Interfacing to most modern transceivers is pretty easy.  The task is to
  pull a small positive voltage to ground, which can easily be done with a
  small signal NPN transistor.  I use an RC filter on the base lead to keep
  RF out of the transistor.  I bought a small (about 2''
                                                           X 2'' X 2'') metal
  box from radio shack and installed a grommet for a joystick cable (cut-off
  from a dead joystick), a 1/4''stereo phone jack for the paddle, and an RCA
  jack for connection to the transceiver's keyed line.  Put a 2N2222 on a
  small piece of ``perf board'' circuit board.  The collector goes to the
  keyed line (RCA jack), the emitter to common, and the base through a 200
  ohm (approx.) resistor to pin 1 from the joystick.  Connect a 0.001 uf
  capacitor from each side of the resistor to common.  Wire the dot, dash,
  and common leads from the joystick cable to the appropriate phone jack
  terminals.  You could also install a small pushbutton in the box for a
  remote COMMAND button.

  Internal logic for paddle sending:

  Some keyers don't give you enough time to get off the paddle before the
  next element latches in, so you might send "1'' when you meant ``J''.
  Others have the opposite problem.  I put a lot of thought into this before
  starting and decided on this scheme:  I divided each element of Morse time
  in half.  If you're squeezing both paddles, you have until the second half
  of the current element (dot/dash) before the opposite element latches in.
  If you have one paddle closed, the same element will latch in if you still
  have it closed after the first half of the following inter-character space.
  I think this scheme gives the keyer a pretty good feel.

  Other oddities:






  When you enter the command mode, the keyer automatically takes you off the
  air (stops keying the transmitter).  If you are using only your
  transceiver's speaker (not your TV/monitor's audio or your 800's built in
  speaker) to monitor your sending, this can come as a bit of a shock when
  you are entering commands from the paddle, since you suddenly can't hear
  what you're sending.  So in this configuration, use the keyboard.

  If you're composing a message from the paddle (not really the most
  efficient way to do it ... ), you need to know a couple of special
  characters reserved for the purpose.  Double M (----) will cause a
  backspace, and EOM (sent as one character) (.-----) is the end of message
  character (same as Escape from the keyboard).

  KEYER.OBJ uses cartridge space RAM, so if you have an XL/XE, boot without
  BASIC, (Hold down OPTION while booting), or it won't run.

  Features It Doesn't Have:

  I consider this to be one of the most full featured keyers available.
  However, I never got around to putting in automatic serial number creation
  & incrementing desired by some contesters.  Also, I originally intended a
  command to toggle from left handed to right handed (swapping the dot and
  dash input pins in software).  Maybe someday ...

  One feature I never intended to incorporate (but people look for it), is
  the ability of the program to copy Morse from a radio's speaker output.
  I've seen a number of programs and devices that do this, and I own a few,
  but I consider them an interesting novelty at best.  They can do an
  excellent, even perfect, job of copying high speed  machine perfect code
  under ideal conditions of no noise and no interference.  But there's simply
  no way such a system can compete with the human ear under the demanding
  conditions of noise, interference, and human generated code routinely
  encountered by serious CW operators.

  Conclusions:

  The WA5BDU keyer was a labor of love that consumed all of my hobby time for
  a couple of years.  I originally anticipated expanding it to include
  logging, transceiver control, etc.  But the number of Atari users dwindled
  and I haven't had the energy to translate the whole thing to the PC and
  start over.  (The PC, in many ways, doesn't have as many resources to offer
  the programmer.)  The program is written in assembly language using the
  Atari AMAC assembler.  I will give out the source code to anyone who would
  like to have it.

  73 and enjoy this keyer!

  Nick Kennedy, WA5BDU
  300 South Vancouver
  Russellville, AR 72801
  (501) 967-3843

