Man Linux: Main Page and Category List

NAME

       morse,  QSO  -  Morse-code trainer and QSO generator for aspiring radio
       hams

SYNOPSIS

       morse [-i] [-I] [-r] [-n num] [-R num] [-N num] [-C charset] [-w num]
             [-f num] [-v num] [-g num] [-f num] [-e] [-c] [-b] [-a] [-l] [-m]
             [-t] [-T] [-s] [-q] [-p num] [-E num] [-M num] [-d] [-A] [-B]
             [-S] [-x num] [-X num] [word...]

DESCRIPTION

       The  morse  program  is  a Morse-code trainer intended to help aspiring
       radio hams pass the 5-word-per-minute Element 1 test. It can take  test
       text  from  a  text  file  on  standard  input,  or test words from its
       command-line arguments, or generate random text (-r) or play back  what
       you type (-i).

       A  helper program, QSO, generates plausible QSOs that can be fed to the
       standard input of morse.

       The following options control the behavior of morse:

       -i     Play what you type.

       -I     Like -i but don’t turn off keyboard echoing.

       -r     Generate random text. Starts out slanted towards  easy  letters,
              then slants towards ones you get wrong.

       -n NUM Make  words  (groups)  NUM  characters  long.  Valid  values are
              between 1 and 20.

       -R NUM Set the total time (in minutes) to generate text.

       -N NUM (default 0 means unlimited)
              Set the total number of words (groups) to generate.

       -C ’STRING’ (default all available characters)
              Select characters to send from this STRING only.

       -w     words_per_minute

       -f     frequency_in_hertz

       -v     volume (zero to one, rather nonlinear)

       -g     alternate_frequency (toggles via control-G in input  FILE  at  a
              word break)

       -F     Farnsworth_character_words_per_minute

       -e     leave off the <SK> sound at the end

       -c     complain about illegal characters instead of just ignoring them

       -b     print each word before doing it

       -a     print each word after doing it

       -l     print each letter just before doing it

       -m     print    morse   dots   and   dashes   as   they   sound   (this
              printing-intensive option slows the wpm down!)

       -t     Type along with the morse, but  don’t  see  what  you’re  typing
              (unless  you  make  a  mistake). You are allowed to get ahead as
              much as you want. If you get too far behind  it  will  stop  and
              resync with you. You can force it to resync at the next word end
              by hitting  control-H.  Hit  ESC  to  see  how  you  are  doing,
              control-D  to  end.  (The  rightmost space in the printout marks
              where the average is. Farther left spaces separate off blocks of
              letters  that  are  about  twice  as  probable as the average to
              occur, three times, etc.)

       -T     Like -t but see your characters (after they are played).

       -s     Stop after each character  and  make  sure  you  get  it  right.
              (implies -t)

       -q     Quietly resyncs with your input (after you make a mistake).

       -p NUM Make you get it right NUM times, for penance. (implies -s).

       -E NUM If  your  count of wrong answers minus right answers for a given
              character exceeds this, the program will start prompting you. If
              above  the  maximum  error  prompt it will never prompt (implies
              -t).

       -M NUM If you get more than this number  of  characters  behind,  pause
              until  you  do  your  next  letter. 1 behind is normal, 0 behind
              means never pause. This option mplies -t.

       -d     Dynamically speed up or slow  down  depending  on  how  you  are
              doing. (if also-s, then -d only speeds up!)

       -A     Add ISO 8859-1 (Latin-1) signs to test set.

       -B     Add uncommon punctuation to test set.

       -S     Add uncommon prosigns to test set.

       -X     Set error volume. Error volume 0 means use console speaker.

       -x     Set frequency of error tone.

       Here  is  the  basic  International  Morse codest that the program will
       train you in:

                      A  .-          N  -.          1  .----       .  .-.-.-
                      B  -...        O  ---         2  ..---       ,  --..--
                      C  -.-.        P  .--.        3  ...--       ?  ..--..
                      D  -..         Q  --.-        4  ....-       (  -.--.
                      E  .           R  .-.         5  .....       -  -....-
                      F  ..-.        S  ...         6  -....
                      G  --.         T  -           7  --...
                      H  ....        U  ..-         8  ---..
                      I  ..          V  ...-        9  ----.
                      J  .---        W  .--         0  -----
                      K  -.-         X  -..-        /  -..-.
                      L  .-..        Y  -.--        +  .-.-.
                      M  --          Z  --..        =  -...-

       The following characters are included if one uses the -B option:

                      )  -.--.-      "  .-..-.      _  ..--.-      ’  .----.
                      :  ---...      ;  -.-.-.      $  ...-..-     !  -.-.--

       The following procedural signals (prosigns) are also  included  if  one
       uses -B:

              <AR>     "+"  over,  end  of message <AS>    "*" please stand by
              (<AS> 5  Wait 5 Minutes) (".-...")  <BT>     "="  (double  dash)
              pause,  break  for text CL          going off the air (clear) CQ
              calling any  station  K            go,  invite  any  station  to
              transmit  <KN>     "("  go  only,  invite  a specific station to
              transmit R           all received OK <SK>    "%" end of  contact
              (sent before call) ("...-.-", known also as <VA>)

       The  following  less-used  prosigns  are  included  if  one uses the -S
       option:

              <AA>    "^" new line (".-.-", the same as :a,  ae)  <BK>     "#"
              invite  receiving  station  to  transmit ("-...-.-") <KA>    "&"
              attention ("-.-.-") <SN>    "@" understood ("...-.")

       The following characters are included if one uses the -A option:

                      :a  .-.-   (also for ae, the same as <AA>)
                      ‘a  .--.-  (also oa, danish a with ring over it)
                      ch  ----   (bar-ch ?, bar-h ?, ISO 8859-1 code  199  and
              231 ?)
                      -d   ..--.   (eth,  overstrike d with -, ISO 8859-1 code
              208 and 240)
                      ‘e  ..-..
                      ~n  --.--
                      :o  ---.   (also for oe)
                      :u  ..--   (also for ue)
                      ]p  .--..  (thorn, overstrike ] with p, ISO 8859-1  code
              222 and 254)
                      paragraph  .-.-..  (ISO 8859-1 code 167 ?)

       For  the  raw  beginner  trying  to  learn morse code, we recommend the
       following sequence:

       1. Start learning the alphabet:

          morse -r -s -T -d -w 5 -F 15 -p 5 -E -10

       2. Then drill drill drill:

          morse -r -s -T -d -w 5 -F 15 -p 5 -E 0

       3. Real-time drill, with hints if you really need it:

          morse -r -T -d -w 5 -F 15 -M 2 -E 4

       4. Simulated test:

          QSO | morse -e -T -d -w 5 -F 15

       5. The dreaded random-letter test:

          morse -r -T -d -w 5 -F 15

       6. Finally try for greater and greater speed:

          morse -r -T -d -w 13 -F 24

AUTHORS

       Joe Dellinger <joe@montebello.soest.hawaii.edu>.

       Updated 2005 by Eric S. Raymond <esr@thyrsus.com>.

       Other contributions by Jacek M. Holeczek and Marc Unangst.