MCPT User Guide

Generate customized practice content for listening to Morse Code with your favorite tutor/trainer software. Compatible with LCWO, G4FON, PCWTutor, and more. Simply give the generated file to your training software to hear Morse Code the way you want it! Words, code groups, prosigns, or combinations of all of them. Random or selected. You choose the, word or group lengths, characters used, amount of practice material to generate. MCPT is very flexible so provides variety, fun and challenges for your learning session.

Users of LCWO.net (here after LCWO), can enjoy the challenges and benefits of on-the-fly speed changes, with specialized features.

Overview

This file contains examples of the usage of all options.

mcpt overcomes some of the common issues with practice text, or its generation:

1. limits typing or editing to create text
2. flexible input sources
3. better distribution of random data
4. user control of input matching criteria
5. user control of duplication
6. random output to eliminate memorization
7. sending code features

Overview Of MCPT's Behaviors

1. code groups: -codeGroups (typical random strings: UUMRK MU.4R)
2. permute: -permute (2-3 character code group giving every possible permutation: KMU, MUK, UKM)
3. words: -text (words from a file: NAME RIG QSO WX)
4. call signs: -callSigns (generated from known characters: W1KMU K2MM WA4QWE/QRP)
5. mixed words and code groups: -mixedMode (HELLO RIG KMU?3R BYE NAME 4RED=)
6. general strings: -in (read from file: HELLO RIG 98.6 80KHZ KA2ABC <SK/ QRS?)
7. sending: -send and -sendCheck

First read of document? You may want to skip ahead to General Option Examples.

Options: format, evaluation, use of <optFile> for file vs cmd line

Note: Zeros written to the screen have a slash for readability, they are printed unstriped with <-outFile> option so tutor/trainer software does not have problems. For this reason do not use the commmon command line practice of file redirection using ">".

An simplified method of using a file of options, just as -optFile, is to ONLY give the file name following mcpt, i.e. : mcpt file.txt. No other enties on the command line. This is quicker for instructors during live training, however it does not let option values be overridden, or a file be created as the -optFile allows.

Notation

To minimze typing, some option name are a concatentation or abbreviated words, for example: preLen for prefix length; cgList for code group list.

The following options all have a minimum and maximum value, the values are given in one option. They are: sufLen, cgLen, inLen, lesson, and DM. (DM is a quantity not a length). E.g. -inLen=5, is a short hand for -inLen=5:5, which means the minimum and maximum value for this option is 5. A value such as 3:6, is a random value between 3 and 6, inclusive.

The help usage will remind you about these options, you will see the default value written with the colon notation.

Options on the command line MUST be preceded by a "-".
Options on the command line MUST be separated from each other with a space.
Options with a value e.g. -opt=2 or -opt="abcd" use an "=" as a separater.

If you specify the option optFileon the command line with other options, and that option file does not exist, MCPT will offer to CREATE it for you. This is a simple way for a user to build up a command line, test it, and then preserve that behavior for future use.

A few more notes on option format:

1. a "-" MUST precede the option name (no spaces)
2. list options may contain supported ProSigns whith format like <AS>
3. option names MUST be in the case shown
4. after the name, if there is a value put an "=" immediately follow by the value
5. values have 3 possible types as listed in the options table below
int (integer) are digits, and always >= 0, like: -inLen=8
6. bool (boolean) turn an option on/off, values are: true for on, false for off
7. string options should have values within double quotes, must be quoted if it has a space or "="
8. inlist values are case sensitive since its used to match input text
9. if inlist contains a "?", then a "?" following a word such as: cpy?, qrl? will be matched
10. option values in: ist, sufList, cgList, delimiter are not case sensitive

To increase the occurance of a character, you can increase its presence in the list option. For example, if you want code groups to favor X and Z, you could make cgList="A-ZXXXZZZ", the odds of an A is 1/32, but X and Z is 4/32.

An alternative to the above, option <favorLast> will increase the likelyhood of the LAST 2 characters, in option <cgList>, this includes the use of cgList when you use the lesson/tutor options.

An example options file, with comments, follows.

      # this is a comment line
      // as is this 
      # a blank line as below, is OK too

            # this comment line is indented with whitespace
      # below are two formats for the "min" option 
      # you can use either of these formats
      inLen=4   # comments can be at the end of lines
      inLen 4   # no equals NOT recommended
      -inLen=4  # preceded with minus, unnecessary
      #
      # to temporarily eliminate an option just comment it out as below
      # len=80
      #
      #DONE  A SPECIAL COMMENT, THIS ENDS THE PROCESSING OF THE OPTION FILE
      #END   A SPECIAL COMMENT, THIS ENDS THE PROCESSING OF THE OPTION FILE
             Lines below are ignored without the need to edit or comment them.

      Note: To comment out a block of lines, use the standard programming 
            block comment rather than many uses of the "#" character.
	    See below:

	    /*
	    num=100 
	    len 80
	    */
	    # above the "/*" starts comments and "*/" ends the comment

The command line option displayFormat (with values LF, TAB,LF_TAB, TAB_LF in upper or lowercase), will change the whitespace in output for readability.

They are only for readability, if desired. They replace spaces in output with TABs, and LF adds a linefeed (or blank line) between output lines.

Additionally, there are several list type options: ist, sufList, cgList, inlist, and must.

On the command line or in the options file, these list options are treated as if they were just a collection of characters AFTER 2 parsing operations for the users convenience. So if you want code groups to contain any of a set of characters it would look like this: cgList="EIOTA27?". Each character is a standalone entity. Now for the two special situations. To save you typing, LETTERS (upper or lowercase) or DIGITS can be entered using range notation. In range notation, A-H, is the same as typing ABCDEFGH, the only two criteria is the first character must come in dictionary order (A-D is good, D-A is invalid), and each range is independent (A-z invalid, A-Z good). Digits similarly go from 0-9.

Delimiter Option - what a delimiter is

This option contains one or more fields of strings, they are NOT individual characters. Delimiter="ABC" is one string of "ABC", NOT an "A" or "B" or "C". If the delimiter were used with a word input file: "this is a test", the output would possibly be "TEST ABC IS ABC THIS ABC A". Most likely, you want variety for better learning, so consider a delimiter with multiple fields like: delimiter="ABC|34|Z|?|,.". Now with the example above, the output might be: "IS 34 TEST ,. A ABC THIS". More useful delimiter now might be: "CQ|DE|QTH|RST|<". NOTE lets look at those last two fields, this is the other way why a delimiter is different than the other lists.

If the field (data between the '|'s or a '|' and the double quote contains a range and other characters (letters, numbers, another range) then the range is simply expanded as seen already. So that last field is used as if you had typed "ABCDEF123"; and that entire sequence is what would apprear between words. HOWEVER if the field contained, ONLY a simple range, as in the next to last field above "|a-f|" this is expanded as if you wanted EACH character to be treated as if it were its own field. Said another way the field "|A-F|" is treated as if you typed "A|B|C|D|E|F".

Use of Delimiter - sample delimiter usage

While the fields of a delimiter can be a word or meaningful sequence like "QTH" or a ProSign like <AR>. Later in the document you will see that many features can be used in one execution to generate practice text to suit your current training needs. Using input words, code groups, delimiters, ProSigns and some random flags you could get very varied practice like: "THIS 38 TEST 78 IS 838 4F?,7J PRACTICE 321 GENERATED NW4,7D.,".

Options Help Information - getting runtime help for options

General Option Examples:

As with any new tool or skill, you will learn best by trying and experimenting. Copy commands and try them yourself.

NOTE: in many examples, the command line has "..." this means are are other options that can or may need to be added, but the discussion is highlighing the other options.

Example 1: some options for "word" practice

NOTE: 30 words between 3 and 6 characters from text.txt
NOTE: words in random order
NOTE: less than 30 unique words found, so we reuse some 
NOTE: string in  or  preceded by a "#" are skipped, so you can skip words from being used
      

See example 32 for contrast of -in vs. -text.

MCPT MORSE MAY ARE YOUR TUTOR 
THAT THAT TUTOR NOT FOR CAN 
TRY USE MAY TRY OFFER TEXT 
MCPT YOUR TEXT ARE LINE MORSE 
LINE CAN WHICH YOU FOR NOT 

NOTE: -len=30 shortened output to 30 charaters (words not truncated or split)
NOTE: option value can use a space or equals separator e.g. -inLen 4, or -inLen=4

*** In the following examples, we used more defaults options for brevity.

mcpt -optFile=myOptions

Note: opt myOptions, will override default options.
      Command line options have the final say.

Writing to file: out.txt

NOTE: out.txt shown below
YOU WHICH7 FOR= LINE1 TEXT/ MAY8 USE9 THAT5 CAN= 

NOTE: -sufLen=1:2, appends one or two random character from default sufList as a suffix. sufList defaults (see help).

THAT/7 YOU04 LINE8 TEXT78 MCPT. WHICH95 FOR20 CAN7? MAY= USE18 

NOTE: -en works just like -sufLen and by default uses the same characters (see help)
NOTE: below is example of -sufLen=3 and -en=1

8WHICH.. 3TEXT58 5YOU3 8USE2 ?MAY97 1CAN1, ,FOR/. 9LINE=8. 6THAT/7 

*** Default suffixes and prefixes can be changed with -sufList and -ist as appropriate. 
*** Duplicating a character in sufList or ist e.g. ".,???????" increases 
    the probability of that character in output.

1MORSEz 1OFFERZ 2OFFERZ 1WHICHZ 3MORSEQ 2TUTORQ 1TUTORZ 2WHICHQ 2WHICHX 3OFFERQ 

NOTE: prefixes limited to values of: 1, 2, 3; suffixes to Q, Z, X.

MORSE/, TUTOR245 MORSE1=7 WHICH?9 OFFER WHICH= 36/ OFFER9 OFFER=5/ TUTOR7 WHICH57 

NOTE: a space character added into the sufList or ist set of characters.
      The result of the space is seen above in the underlines output.
      In the case of, "offer", the tool was going to put just 1 suffix character, since it was a space
      its unseen. In the case of, "WHICH= 36/" the suffix length was 4, but the second random character 
      was a space, so it "looks" like a non-word output.

OFFER ARE OFFER FOR USE USE ARE MORSE ARE ARE USE FOR OFFER OFFER MORSE MORSE 
USE FOR MORSE FOR 

NOTE: Use -inlist if you haven't learned the entire alphabet, or just want word practice on 
      a limited set of characters. The output is limited to the inlist set (A-Za-z).
NOTE: You can use a character range, like A-F, instead of ABCDEF - but it must be in ASCII table 
      order (e.g. F-A will fail). "a-dhijx-z", "a-dD-G0-8" are good.
NOTE: The set is NOT limited to letters, e.g. you could include an apostrophe to match "her's", but 
      over doing this is going to start to look like code groups, if the input is not regular text.
NOTE: Regardless of the value of inlist or lesson, a prosign found in the input file will be treated 
      as a "word" as long as the option "min" is greater than 3 or 4 (depending on format ^XX or ). This <SK>, ^sk, for example 
      are treated as a word. The two characters are NOT verified, so <ZZ> is a good as a real 
      prosign for matching purposes, its up to your tutor software to treat it appropriately.

      If any list type option contains a "=" or " ", the value part MUST be quoted. 
      E.g. ist=".,="

*** sufList and ist can also use the character range notation.

YOU9 WHICH7 <BT>? FOR= MCPT. <AR><AS>7 LINE1 <SOS>, TEXT/ MAY8 USE9 THAT5 CAN= 

NOTE: Each ProSign seen above is in the -prosignFile=prosignFile.txt.
      Prosigns are treated SIMILARLY to matched words, as follows:
      - they appear in upper case regarless of case in file
      - ProSigns are stored BEFORE the input file is read, therefore they contribute toward 
        the "-num XX" quantity.   That is, if the number of ProSigns is greater than num 
	you won't get any words in output.
      - -en and -sufLen add to the ProSigns, just as if it were a word. The same is true for -random
        option. e.g. "8<HH>?"
      - A file entry can have one ProSigns per line (see file sample below).
      - File lines that do NOT match the ProSign format (<LetterLetter>) or (^LetterLetter - this is for G4PON)
        are silently ignored.

      Sample ProSign File:
      
      # The above line is empty. or all spaces so its ignored. As is the next "random" text line.

      <AR>
      <SK>
      <AS>
      <bt>
      ^BT # this format supported to play output in G4FON
      # spaces before or after a ProSign sequence is OK
           <KN>

THE THE THE <BT> MAN MAN MAN <BT> AND AND AND <BT>

Note: the "-delimiter" option is NOT effected by any other option (random, en, sufLen)
`
Note: it is literal, and what ever you want. e.g. '.?/', 'XYZ', '123', 'It can even have multiple parts'.

Note: You can have multiple delimiters, which are selected randomly, by
      separating them with a pipe "|" e.g. -delimiter="<BT>|<AR>SK<".
      for output like: "THE ? AND 4 MEN <SK> SAT . END"

      Also: If delimiter is used, then -delimiterNum=X, where X is the number of delimiters, format X:Y gives a min and max.
      DM=0 therefore means no delimiter, even though -delimiter might have a value.
      As in: delimiter="1|?|=" -delimiterNum=1:3 then the inter-word delimiters might be: 1,?,=,11,=1=,??. 

Note: If a field in the delimiter is only space(s) e.g. ".|?| |=", and DM=1, 
      this will result in NO delimiter if the that field is selected. 
      So output could be: word1 ? word2 = word3  word4. No delimiter between 
      the last two words, your tutor will ignore the extra space.

      If DM was a range from min:max, then a random number between min and max will be
      the number of delimiter fields to concatenate together to make the value
      for output e.g. DM=1:4 could produce "=??", output therefore could be:
      word1 =?? word2. But if there is a space in the delimiter, you could get 
      a multipart delimiter e.g. "=? ?", output could be: word1 =? ? word2.

Note: If a field contains a prosign of either format, ^XX or <XX>, the filed cannot conatain anything else.

Note: A delimiter is NOT counted as a "word" or codeGroup, so -num=4 for examplecould display "one xx two yy three xx four xx" even though the delimiter in some cases might look just like a word or codeGroup.

Note: ONLY FOR LCWO USERS: if a delimiter field contains an asterisk (*), that will translate into 
      a 1/2 second silence period during playback. This may be used with any feature where a delimiter
      applies, but may be most effective in conjuction with the <repeat> option.

ie3?k 40kee ia?2?

Note: case in cgList does not matter, output will be upper case
Note: group length determined by and -cgLen
Note: groups can be separated by delimiters as previously described
Note: limited options apply when using code groups, others are silently ignored
      -len, -num, -delimiter, -delimiterNum, -outFile, -inLen apply.

VISIT OTHER =,0-A0 ABOUT SHARE -=?A=-? MYSELF THOSE 

Note: Every "2" words printed from matching in the input file is followed by 
      a random code group (from characters in cgList).
Note: all options from word match word still apply if used (en, sufLen, delimiter, etc.)
Note: In mixedMode, the code group word is NOT counted into the -num word count.

The output from this option "looks" like a simple set of short code groups, but its special.

Code groups are random, therefore it is possible you might never see some characters next to each other.
Likewise, you might do a lot of word practice, and never encounter certain combinations. Rather than wait until 
you encounter them on the air, maybe with call signs, this feature can help.

The permute option, by default, will use the tutor and lesson options to determine which characters to permute.

Note: 0 is the default lesson option. The supported tutors all start with lesson 1. 

For the command line above, the characters to permute are: "KMU". The value "p", to permute means you want pairs,
therefore the permutations would be: KK MM UU KM KU MU MK UK UM. Because this would be a very short practice session,
there pairs will be repeated (in random order) until the value of the word option num, the default for num is 100.
If you ONLY want the minimal set, simply use num=1. (Num will be ignored if it would cause a loss of a permutations, for the
value of "p" or "t".)

The num may limit permutations, but it will NOT create more the the valid number. Permutations grow quickly, so generally you'll use
the option for limiting. (Remember -num=100 by default.)

All the pairs are good, but in the practice of pairs, a character either follows a space, or has a 
space after it, so permute has another value form permute=t, which indicates you want "triples". Changing the 
command line above to -permute=t, gives the following: MKM UKU KMK UMU KUK MUM. We now have each character, where 
it is not next to a space. (Some permutations have been suppressed; there is no MMM, for example 
(3 M's doesn't give you anything that 2 didn't already), there is no MMK, KMM for the same reason.

Lastly, you might want a practice session with both pairs and triples, use -permute=b (b for both).
As the lesson number gets high, the output size get significant, LCWO will simply truncate a file that's too 
big (8000 characters) (other tutors may act differently).

For the case of "b" for both, this is NOT lower limit of output, the num option has total control of the 
qunantity of output.

Most word practice and code groups will of course hit many of these permutations, if you want to work on a set of 
your choosing you can drop the lesson= option, and instead use the code groups list option. For example:

mcpt -cgList="qrx5" -permute=b num=1 

Generates:

QRQ 5R5 5X Q5Q QXQ X5 R5R XQ 55
XR RXR 5X5 X5X XQX Q5 QQ RQR 5Q
RX R5 XX QR RQ QX 5Q5 5R RR XRX

Prosigns were previous supported with an input file <in=my.txt>, but if used with options
<codeGroups> or <mixedMode>, the Prosigns in the prosign file <prosign=myps.txt>
with ONE prosign per line (see below), will use these 4 character sequences (e.g. <<SK>) as
if the were a single character in the <cgList> option for code groups.

File myPs.txt
<SK>
<HH>
<AR>

A code group of fixed size of 4 (cgLen=2:2)could look like:

X3FQ JDUG J2S NEFS <HH><SK>z<AR>

Similarly if the command line ws using an input file for words but usig <mixedMode> for
codeGroups, as well, the codeGroups could have prosigns.

The following command, sets inLen=1 and inLen=15 so that no words will be discarded, Also, num was set to 11 so that no words are discarded and none are used more than once. ordered output stays in the same order as the input. len was set short, so that you can see that if a line is longer, but a word is straddling the length boundary, that that word is finished rather than having a word split.

mcpt -inLen=1:15 -num=11 -inFile=words.txt -ordered -len=20 -outFile=myOut

The text below is the output now in file=words.txt. Note, that the first word was captured even though it started with an uppercase, that's because the default character matching characters is option inlist is "A-Za-z".

` this is the content of myinput file to demonstrating reverse option

Now we'll reuse the command, adding the reverse option, and changing the input file name to be that of the output above. The text following the command has each word reversed. (Suggested William Pierpont's document. You retain letter frequency of the input, and eliminate anticipation.)

mcpt -inLen=1:15 -num=11 -inFile=words.txt -ordered -len=20 -reverse -outFile=myReversed

SIHT SI EHT TNETNOC FO TUPNIYM ELIF OT GNITARTSNOMED ESREVER NOITPO

Now for the acid test, lets reverse again to get back the original text (same words, same order, same line length).

Note: I purposely have the option in two times, just to remind you that it is the right most option that overrides a prior value, just as command line options overrides the same option in the options file (if used), and that in turn overrides the built-in default. This may seem like over kill, but with so many options it does make for easy and limited typing to change the tools behavior for different practice text generation.

mcpt -inLen=1:15 -num=11 -inFile=words.txt -ordered -len=20 -outFile=myOut -reverse -inFile=myReversed -outFile=myFinal

THIS IS THE CONTENT OF MYINPUT FILE TO DEMONSTRATING REVERSE OPTION

Final comments. This was a carefully crafted to demonstrate several features. The fact that this still looks like a logical sentence is based on the fact that all words in the input were unique, nothing got discarded and we keep the same order. This is not the design intent of this tool, use your input directly with a tutor (no mcpt) if you simply want text-to-cw without processing.

Example 18: delimiters on a random basis

As previously discussed, DM=1:2, would give 1 or 2 delimiter strings concatenated between each word.

WORD 1 WORD A? WORD ≪BT> WORD AA WORD <BT> WORD ?

with -delimiterRandom (a.k.a. delimiterRandom=true) you indicate that delimiter printing is random

WORD WORD WORD <BT> WORD AA WORD WORD 1

Example 19: controlling the length of code groups when intermixed with words

ON AT OF 3,A??4 NO HE IS A4263?/ AND HAT FOUR ......

Example 20: randomness of the intermixed code groups with words

This input file for this example is a simple list of short words. The first line of output follows:

ON AT OF 3,A??4 NO HE IS A4263?/ AND HAT FOUR ......

NOTE: In the above, after every 3 words (mixedMode=3) we get a code group.
      We can add an option -MMR (mixed mode random) which gives a 50/50 chance that a code group will be 
      suppressed to lessen predictability.

mcpt -inLen=2:4 -cgLen=6:8 -mixedMode=3 -inFile=words.txt-MMR

NOTE: The stretch below with no code group due to -MMR.

ON AT OF 3,A??4 NO HE IS 4263?/ AND HAT FOUR IN AND ON HAT HE OF ?.23D3 HE SO .....

 ***
 *** IF YOU ARE USING LCWO FOR PLAYBACK AND mixedMode=X, YOU CAN ALSO USE SPEED CHANGES ***
 ***
 

      Most users copy plain text faster than they can copy code groups, with this in mind you might want
      to have the copy above configured with on-the-fly speed changes so the plain text "words" 
      could be sent at a higher speed than the code groups. To do this, we use two more  options 
      we've seen before; LCWO_low sets the low(slow) speed of the code group, and LCWO_step the incremental 
      speed to add to LCWO_low to get the higher speed to use for the plain text.

mcpt -inLen=2:4 -cgLen=6:8 -mixedMode=3 -inFile=words.txt -LCWO_low=20 -LCWO_step=5

|w25 TWO FOUR NINE |w20 FL,WE0 |w25 FOUR TEN ONE |w20 YB251C |w25 ONE FIVE NINE |w20 AJRR7H

      You see the copy starts with the speed at 25 wpm (speed changes look like |wXX), that's 
      LCWO_low=20 + LCWO_step=5.
      You see prior to each code group (underlined above) the speed drops.

      In the above generated text for LCWO (you can paste this line into "Convert text to CW" screen)
      the in-line speed changes are underlined with dashes, the plain text (played at high speed) 
      (in italics).

      Of course -MMR could also be used as previously described (not shown again).

      As shown in example 16, if the user desires two other options LCWO_sf (slow to fast transition) 
      and/or LCWO_fs (fast to slow) can be given a string (character(s), ProSign) which provides an 
      audible alert in Morse code that the speed will transition. If used, the alert string is sent 
      PRIOR to the speed change.

      Just to demonstrate, let LCWO_sf=,, and LCWO_fs=??

|w25 four two nine ??|w20 ha?l50 ,,|w25 nine ten five ??|w20 tof=u9 ,,|w25 six four four 

      Above the simple alert strings are underlined with dashes, they occur just before the LCWO speed
      change.

      *** What might be more fun, is instead of using LCWO_sf and LCWO_fs having some characters as an alert,
          to instead make use of another LCWO feature, that is change the tone frequency of the code groups.
	  The line below uses frequency changes, you can cut and paste this into LCWO's "Convert text to CW"
	  to try it. (To generate this I used -LCWO_fs="|f750" and -LCWO_sf="|f600" the initial tone of 600 HZ 
	  can be set in the browser with -header="|f600". 

|f600|w25 FOUR TWO NINE |f750|w20 HA?l50 |f600|w25 NINE TEN FIVE |f750|w20 TOF=U9 |f600|w25 SIX FOUR FOUR 

      The first underlined, sets: 600hz 25wpm.      
      The second underlined, sets: 750hz 20wpm       

      Or better yet! Instead of changing the tone of the code group, or using a text alert, we can 
      generate a short signal by using letter E or T framed by a short amount of silence (200ms in 
      this example) and just changing the tone of that one letter. Make LCWO_fs and 
      LCWO_sf="|S200 |f860 E |S200 |f680" (note spaces are required.)

      The copy is below. Start at 680 HZ, play 3 words at 25 wpm, a high pitched E framed by some 
      silence, 2 words at 35 wpm, and repeat the cycle until the -num XX words have been output.

|f680 |w25 ROWDYISM WAGONS SIN |S200 |f860 E |S200 |f680 |w35 IRKSOME UNICYCLE |S200 |f860 E |S200 |f680 |w25 SELLERS 

Example 21: using the options <tutor> and <lesson> to limit generated material to characters you have learned

Setting a lesson number and tutor, will populate cgList (for code groups) as well as inlist (for parsing and matching words in input file) In the command line given, cgList would now be "kmure", and inlist would be "kmureKMURE". This is the last option set, so it overrides any earlier setting of cgList and inlist, both option file and command line.

Range values are 1-40, setting 0 leaves inlist and cgList per their defaults, option file or command line which ever last last.

If you use Morse Elmer, Just Learn Morse Code, MorseCodeNinja, or G4FON you will specify the tutor with tutor option, this will populate the options inlist and cgList with the characters and in the order that they are taught with those products.

Example 22: an example of linking words in a word file to be treated as one word

If you use word input mode via option , you can have a "word" as defined by the  characters
grouped with one or more other words by use of the character "~", for example: MY~QTH~IS. This group will be treated as
a new word (if each piece conforms to , this enable you to get an ordered sequence where words are
normally random. Note: a " ~"  or "~ "  word (e.g. ~MY, MY~, ~M~) will be ignored.

Since this new group is treated as ONE word, other options will apply to the group, NOT the words that make it up. That is
if you are using prefixes, suffixes, repeat, delimiters, this applies. The following is an example:

THIS89 HAS23 SUFFIX22 THIS IS A GROUP99

TEST ?, WORD =. MORE ?? THIS IS A GROUP =? etc.

Example 23: generation of some call sign formats

The intent of this feature is to give the user the ability to get some call sign copy experience before learning all the characters, also to give some options that their tutor might not provide.

This is NOT a full fledged call sign trainer. The ITU has many exceptions to it's call sign format rules, as do the host countries. The call signs are "generated", in ITU general format, with some limitations. The ITU specifies a call as a PREFIX+NUMBER+SUFFIX. For prefix notation they use "P", so PPNS, means 2 prefix characters, a number (0-9) and one suffix character. Most hams would say W2AB is a 1x2, or 1-by-2 call vs. a PNSS.

MCPT will generate prefixs of P,PP,PPP (not PPPP since its rarer), also for each "P" it will use ONLY alpha characters (the left most is never a "Q").

Similarly, for the suffix, MCPT will generate S,SS,SSS not SSSS or SSSS, and again with alpha characters only.

The practice is for call sign "format", the actual generated prefixes may not be assigned to any country. For the same reason as above, a country code before the assigned call (e.g. DY/WB4ABC/QRP) are not generated.

*** LCWO lesson=23 is the first lesson with a number, "5" in this case. From *** this lesson on we can generate call signs for practice since a number is required.

mcpt -callSigns -lesson=23 -tutor=lcwo

SZ5R PN5LWT W5FAV GS5RZ K5WAW AK5UFR M5WO ME5J VT5RRM

*** LCWO post lesson 27, we have learned "/" and now 2 numbers. We now have randomly *** some common trailing information that can be appended to the call: /p=portable, /m=mobile, *** /mm=maritime mobile, /qrp=low power station, as well as a fixed station at other than *** their normal location e.g. /4 for W2AA, as in W2AA/4.

mcpt -callSigns -lesson=27 -tutor=lcwo

H0QG VD5CS/1 M0DU/7 SG2PE/P MJ3ZM RT7N/M BZ2WF/QRP SU4ZAP Y4B W9I/MM

*** For head copy practice, repeat a call more than once and with NO lesson or *** tutor option, the full 40 characters (more precisely 26 alphas, 10 numbers, *** and slash) are used.

mcpt -callSigns -lesson=27 -tutor=lcwo -repeat=2

IM0G/2 IM0G/2 ET3WPQ ET3WPQ P9GW/QRP P9GW/QRP IH5GZX IH5GZX IT8MC/M IT8MC/M

*** Lastly, you can still use the 2 options delimiter and DM, to get inter-call *** sign delimiters. This enables you to get NON call sign practice in the *** practice session. The example below is using a few prosigns and punctuation.

mcpt -callSigns -delimiter="<SK>^<BT>^.^,^?" -delimiterNum=1:2

E6WJ <BT>, JZ8O <SK> D5KTI/3 <BT><SK> UR3J/1 <SK> E1O/M ,<SK>. JU5RFP/QRP

*** Note 1: To check the tutor-to-lesson correlation use:

mcpt -help=tutors Users of LICW, use -help=LICW for details on which are different than other tutors.

*** Note 2: You can customise your character use independent of a specific tutor as with the cgList option. I.e.:

mcpt -callSigns -cgList="123abcdef"

F2CFF B3F D1DCF EB2BC AB1DE FB3EBC DC4DAB CB2BFA ED4AAA

Limited call sign practice can be done without the "callSigns" option; in this case you control the prefix, number, and suffix portions using other options. Here is an example.

 mcpt -preList="kw" -preLen=1    -codeGroups -cgList="0-49" -cgLen=1     -sufList="kt" -sufLen="2:3"

Possible output:

K2KT K9TTK W0KK W4TKT ....
 
Note: lengths with just a number means that number is the mix and max, thus a fixed length; a length like 2:3 means a minimum
of two and a maximum or 3. Also note the dash notation means the left character through the right inclusive; so 0-49 means 012349
just as a-d means abcd, they are just shorthand notations.

Example 24: <displayFormat> for better readability of displayed output (usually for sending practice)

This option cosmetically changes the output. It can take 4 different options, LF (add an extra linefeed), TAB (conver spaces to TABs), and to get both actions you can use either TAB_LF or LF_TAB.

These are for user reading, that is if you are giving the output to a tutor/tainer to play code as audio they have have no value. Some users use MCPT ouput for sending practice, and some have even used it for keyboarding practice. The following shows a small example or code groups, first without the new options, and then using both.

wsdf5 dw34e des,. sdsdw aswss sdj23 sdsdr ./766 36ffd fed34 dsdhh s43??

wsdf5 dw34e des,. sdsdw aswss sdj23 sdsdr ./766 36ffd fed34 dsdhh s43??

Example 25: <must> to ENSURE a given character is used in every output word/code group

Either of the above generate code groups (assuming tutor=LCWO the default) with fixed length of 5 (default cgLen=5 or 5:5); but the new option <-must> means that every group is guaranteed to have one character from the option. This gives a means of concentrated practice on one or a small set of characters rather than just being random.

Note that the characters in <must> are not constrained by the lesson values. Note that must can also be used with < or <text>, in a similar way to substitue one character from the must list.

MKURD KKBUR EUUAM

mcpt -codeGroups -lesson=4 cgLen=1:4 -must="E" In this example the user gets random length groups from 1 to 4, of the letters KMURE; but the the forces every group to have an "E" since its the new character for the user, or the one causing problems.

KRE E MUER EE EMUE

If you want the "/" in , do not put it as the first character, some operating systems may have issue with that.

Example 26: <headCopy> make words progressively longer

Note: headCopy may not be used with -text option.

The headCopy option will make each successive codeGroup have a length of one more than the previous, until the cgLen hits its maximum value. In the example above, without the new option, the group length would be between 2 and 6 characters. Now, the first group has a length of 2, then 3, then 4 ... until 6. This may help the user to build their ability to mentally buffer the text, a skill needed for head copy. If you use the delimiter option with headCopy, the delimiter will appear in between runs or elements NOT in between each word or code group. A delimiter is therefore an alert that the longest element is done, and the shortest one will follow; its also a handy way to get some practice of a prosign or puctuation. The difference is shown below.

NOTE: *** change the option from headCopy=1 to headCopy=2 with either option <in> or <text> and the output will take a word like "MORSE", and output "M MO MOR MORS MORSE". Use of the delimiter feature like "-delimiterNum=1 -delimiter=<BT&get;" will put a delimiter following the copy of the completed word.

Note: If is added, then the final word when spelling is completed, will be repeated. i.e. "c co cod code code code".

Without -headCopy:   kmmu k ummkr km mm

With -headCopy=1:      km kur rruk kmmur rummkm mm umu kumu uuurr urumkm 

With a delimiter:    mm mkm rmkm mmrkm <SK> um urk rmmk rumkk <AR>

In the second command, the headCopy option does the same thing for words as it did for code groups.

Example 27: <send> creating special code groups for learning to SEND.

After learning to receive all the characters, this option can generate some groups for sending practice, particularly for keyers/bugs with dit/dah alternations.

The following groups numbered from 0-7 determine the characters. The order 
is from simplist to difficult.

0: Special case see the note at the end of the example.
1: EIHMOST50                      # all dits or dahs
2: ABDGJNUVWZ                     # one dit/dah or dah/dit alternation
3: 12346789                       # as above (2 and 3 same difficulty)
4: FKLRPQXY                       # two dit/dah or dah/dit alternations
5: C.,?/                          # three alternations or longer character
6: <AR>&l/;AS><HH><KA><BT><SK>       # ProSigns
7: TAUV456BDN                     # "cut numbers" in order 0-9

The third command above, might generate:

FFY RR QYYY XK
XF LY QKP RPRY

mcpt -send=1,4 -num=200 -displayFormat=LF 
(Adding the option displayFormat=LF, for readability, generates: )

 F5ØHE  OSEMP  OIPMM  RMEFH  RIYTO  R5XQI  THOXF  

 THFRØ  LXLRO  SØIØK  LXEY5  XML5F  5IRØK  RKØQI 

 TFEKP  I5PFP  TQFFH  IPYEX  TQTTY  EKMFO  ØKOIL

Note: If taking on an all the characters of a group at one time is too
      difficult, you can limit the set to those you specify. For example:
      -send=1 "AN" will add "A" and "N" to the characters of group 1.
      You only need the "0" if send does not> include any other 
      groups, e.g.  -send=0 "ABC" will ONLY use those three characters.


Note: If you use your own character string as described above, it MUST be the
      the RIGHT most entry on the command line. 

      Your character string can include supported ProSigns in the <> format.
       

Example 27-2: <sendCheck> for analyzing sending practice sessions

 Reminder: any files given in command line options must be in the current directory, or they must be specified with a relative/full path name. I.e. practice.txt, C:\Users\myHome\practice.txt etc. as appropriate for your environment.
 

 The first file is the practice or source file, the second file is the captured sending.
 

 Note: For compatibilty among multiple products, practice files containing a "+" or "=", will be converted to the more common ProSign format of <AR> and
 <BT> respectively.
 

 If you have other software which allows you to send morse and capture it as 
 text (i.e. PCFistcheck, CWcom, vband, LCWO), then you can verify your sending by 
 comparing the two files. 

1. This feature uses color, a black or dark backgound works best. For Windows CMD/Terminal window, click the top border to change colors; for terminal emulators, look in settings, or mouse click menus (properties) .
2. Even if color is a problem, the first column will indicates if a groupd `had an issue.
3. Timing errors in may be difficult to determine, see the end of this example.

 NOTE: If your capture software, records ProSigns in the format like: <SK>,
       then use a comma "," to separate the file names.
 NOTE: If your capture software, records ProSigns in the format like: ^SK, then
       use a carat "^" to separate the file names.
       MCPT files created with the -send option will use the <SK> format, 
       but it can check either format from your software file.
       MCPT files created with options other than -send (text, codeGroups, 
       permutations, etc.) will use the format based on the ProSign option file.
       So use "," or "carat" as appropriate, as the file separator.

 If you had run any of the commands at the beginning of this example, and added
 the -outFile=text.txt, your practice text would be in that file. To practice 
 sending you would display that file on your screen, and do your sending with 
 your CW sending software (e.g. PCWFistcheck). (Note: Zeros shown on screen 
 have a slash for readability, when saved to a file they do not.)

 Sending practice text material can be generated from ANY MCPT feature, with 
 the exception of the LCWO options. Alternatively, you can use ANY source for
 practice material (e.g. notepad) as long as the file is a simple text file, 
 and only includes the practice text (no: formatting, headers/footers etc.).

 Let's use practice.txt as the name of the generated practice material 
 (from MCPT, Notepad, etc.), as the file to view at to know what to key.
 Let's say your captured morse is in capture.txt. 

 Then run: mcpt -sendCheck=practice.txt,capture.txt
 (File order is important.)

 Below is a simple output. The errored characters will be shown in red text.

  Levenshtein      MCPT Text         Your CW
   Distance          Group            Group
 ============   ===============   ===============
       0        <BT>              <BT>
       1        <SK>              <AS>
       4        HI                HGGGFJ
       1        XYZ               XYZ123
       3        ABCDE             ABC

Accuracy: 50.00%

Note: GREEN text, indicates Your CW capture Group has extra charactes.
Note: BLUE text, indicates Your CW capture Group is missing characters.
Note: Color key and diagnostics will display on screen for you.
Note: INVALID morse shown as: <ERR>, <ERROR>, or <--->, be 
      display as an asterisk (purple or green depending on the column).

Timing Problems With Your Sending

Let's look at the ITU timing criteria, which is what your decorder should be using.

1. A dash is equal to three dots.
2. The space between the signals forming the same letter is equal to one dot.
3. The space between two letters is equal to three dots.
4. The space between two words is equal to seven dots.

With the exception of EXCESS space in the last item, any of these will likely cause the decoding of your CW
to have a negative impact on detection.

SendCheck can help diagnose some timing issues in your sending. For the 
following discussion, let's use the simple practice phrase,
"THIS IS A TEST.".

Mixed case in files are converted to uppercase for comparison.

 Problem: Your "intra-character" timing is too LONG, when you are supposed to 
send "This", the capture software says you sent: "THIEI" or "THIIE" or "THEEE".
This is because the final "S" was not sent correctly, the sending trainer
decoded it as two (or more) letters. We can detect this. These will all be 
shown as wrong and/or EXTRA characters (in red and blue respectively).
 Problem: Your "inter-character" timing is too SHORT, so you compressed "TH" to
look like a "6". Now a 4 character string "THIS" is compared to a 3 character
string "6IS", MCPT will show 3 errors, it will also say you are missing a 
character (in green). Looking at the screen you will realise this was just a
timing mistake. You can edit your file and rerun if you like.
 Problem: You left extra time between words. Like "THIS     IS A TEST",
while not good for on the air sending, this does not cause any screen problem.
 Problem: The worst problem to detect, is if your "inter-character" spacing
is too LONG.  I.e. "TH IS IS A TEST", MCPT will tell you the word "THIS", which
it was expecting is MISSING two characters (in blue, that's good), but from
that point on, you are going to see EVERY word with errors because the two 
files are out of step in their comparison process.  This can be corrected if
you edit the file and delete the space.  (Note: a second error of this type
could put the files back in step, leaving a set of errored words).


As indicated by screen notes and the above list, MISSING (in blue) followed by
many errors (in red) are likely a timing issue. You can follow the directions
or you will be prompted on screen to see if you want to look at the data 
comparison from a timing perspective. In this case, spacing of both the practice
material and the capture material is stripped of spaces and then compared. If 
the amount of error characters (in red) is reduced, then your inter-character
timing is being interpreted as more words than should be sent. Both parts of 
this option should help diagnose sending problems.

Let's look at a more difficult analysis. Checking of "word" sending is not
nearly as difficult as code groups or other complex material.

Assume your practice file (practice.txt) contained: 
"1OOO01 WMNM D34K 6,.8/ VU <BT>THE END".

Assume your capture file (capture.txt), as the decoder of that software 
(PCWFistcheck, cwcom, vband, etc.) 
saved it as: "1OO0O1   WNNN    D34K 6, .8/   VU <BT>THE      END:.

Notice, right away your captured files spacing is rather random (but is wrong?)
and also that comparing this by eye is not a trivail task.

So lets run: mcpt -sendCheck="practice.txt,capture.txt".

Let's look at what mcpt might be able to tell you about this sending session 
from the output below (I've eliminated all the screen titles and notes).
(Note that for the purpose of the document I have used the first column for 
line numbers to refer to.)

     Line           MCPT Text         Your CW
     Number          Group            Group
 ============   ===============   ===============
       1        1000O1            100O01
       2        WNMN              WNNN
       3        D34K              D34K
       4        6,.8/              6, 
       5        VU                .8/
       6        <BT>THE           VU
       7        END               <BT>THE


Line 1: you sent a zero for an "O" and visa versa. 2 characters in error
Line 2: you sent an "N" for an "M"
Line 3: perfect sending
Line 4: Column indicates you should have sent 5 characters, but you missed the
        last 3 or was this a timiing error?
        Looking at column 3, we confirm only 2 of the 5 charactes were sent. 
	However, looking DOWN column 3 although everything is red indicating
	errors, the text looks looks correct. Yes its a timing error! You had
	the case of too long an inter-character pause (space), so your decoder
	made two words instead of one.

At this point you could follow the screen directions and deleted the extra 
space, and rerun the toolfor another look. What may help is to look at the data
without the complication of all the extraneous spacing between words 
(not errors but not desirable), as well as, extra inter-word spacing.

Below is the output for this example.

practice: 100O01WNMND34K6,.8/VU<BT>THEEND
 capture: 1000O1WNNMND34K6,.8/VU<BT>THEEND

Hopefully these two outputs can help you see where your sending needs more practice.

Example 27-3: <review> structured review of learned characters

Use characters, by lesson order or the cgList, and create a review before learning a 
new character. Options, -delimiter and -outFile MAY be used as described below.

The format is as follows for each character in sequence:

 2 groups of 5 of the current character
 8 groups of the current character
 10 groups of the current character AND the last character
 10 groups of ALL reviewed characters so far

This repeats for each character, HOWEVER for every 5 new characters,
there is a review of ALL characters with 30 groups of ALL the characters(the group size
increases by 5 with 5 new characters).

Note: The sample below is formatted, but your code tutor will simply use a SPACE
      where ever there is a RETURN.  In the below you can see where the first 2
      fields of delimiter were used; field 1 (<SK>) alerts you to the start of a
      new character AND for the summary block for every 5 characters. The second
      field <AR> (if it exists) is used to mark the end of sub sections. 
       Do not use a delimiter which is also a character you are practicing 
      or it will be confusing.

 mcpt -review -lesson=2:4 -outFile=lesson2_4.txt (output abbreviated)

MMMMM MMMMM 
MMMM MM MM MMMM MM MMMMM MMMMM MM 

UUUUU UUUUU 
UUU UUUUU UU UUUUU UUUUU
UUU UUU UUU 
UMUMMU MMUMMM MMMMMUM MMMUUM UUMMUU MUUMUU MUMUMUUU UUUMMUUUU MUMUUM
MMMM 
UMUU MMMU UMUM MUUM MUU UUU MUMU MUUU MMMMM MMMU MUMMU MMUMU MUMM MMUMM MUM
UMUU UMUM MUU UUMUU UUMM 

RRRRR RRRRR 

 mcpt -review -lesson=2:4 -outFile=lesson2_4.txt -delimiter="<SK>|<AR>"  (output abbreviated)
Note: placement of delimiters vs. above

<SK>
MMMMM MMMMM <AR>
MMMM MMMMM MMM MMMMM MMMM MMM MMM MM <AR>

<SK>
UUUUU UUUUU <AR>
UUU UU UUU UUUUU UUUU UU UU UU <AR>
UMMMMMM UUUUMU UUUMMM MMUMUM MMUMM UUUUUMUM MMMUUUM
MUUUUM UUMMUM MUUMMUM <AR>
MUMMUM UUMMM MUU MUMMM MMMMUM UMU MMUU UUM UUM UUU UUMUU
MUUUM UUMU MMMM MUMU MUUUM MUM UUUMUU UMMUM MUMM <AR>

<SK>
RRRRR RRRRR <AR>

Note: Below is a sample of what is seen AFTER 5 characters (see the doubled first delimiter).

<SK><SK>
SUU RSESRMS UESE MMESM USEMUMUM URUEM RUSUSU REEM MUERRRS
SUEMMUM RSRRRU MSEUUM EMRS MMRES MSMMMR EERER EMRRUERU URS EUS SMUE UESSU MRUUR RSR
SMMMUS SMRMSRSE EMESE SUURE EMMU EUSMRS ESSU <AR>

 A large lesson count may generate more material than your browser/tutor can handle, manually break the output into
several files; or you can run mcpt several times to cover the lesson range (i.e. lesson=1:10,lesson=11:20 etc.).

This option is only for code groups. It will increase the likelihood of "confused characters". Some learners confuse characters that are mirror images of each other i.e. "F" and "L", some confuse compliments of each other, i.e. "R" and "K". This option will take the random code group generated, and if the lesson number (or cgList) includes BOTH of the confused pair, it will increase the liklihood of getting both characters.

For example, if the lesson using LCWO order, was greater than 10, then both F and L are potential practice letters. If MCPT had generated KFUMS then the <cc> option would detect the F, and then randomly change another character to be an L, as in KFUML. This gives the learner practice of both characters in the same code group.

Note: Group lengths less than 3 are not modified; at most two pairs per group are modified and the selection of them is random as well. 
/

Example 27-5: 
<cc> using characters from -lesson, or cgList get repetition practice

mcpt -lessonList -lesson=5 
mcpt -lessonList -cgList="abc" 

In the default case, the -tutor=lcwo, so the characters of lesson 5 are: kmures.
The output would be ever increasing strings (in order or string), like:

K
KM
KMU
KMUR
KMURE

This continues until the default -num, "words" is reached.

If you add the option -random, then the characters are randomized for the chosen set.

U
UR
URK
URKM ....


mcpt ... -phraseLen=4

This option is simply an count of output words or codeGroups per line.
It adds a newline after the given count. In many code trainers this will simply be ignored like any extra whitspace, however the app "Precision CW Tutor" by DJ7HS has a compatible "phrase" feature.

Used with "Tutor", a phrase is treated as a "word", this lets the use of these two tools together to give the user another means of building head copy skill.

Use the MCPT generated file as input to Tutor; in Tutor use the Hide-Screen feature, as well as the Single Word Mode and a phrase length of your choosing is played. You can head copy and use ENTER or BACKSPACE to get a new phrase or repeat the curent one repectively. Another action can be keep the heard phrase in your head as you key it into another DJ7HS app, called Fistcheck.




LCWO Option Overview: 

(LCWO users also review Example 20)

This section can be skipped if you are NOT a user of LCWO.

For any practice session text where you want to have on-the-fly changes in word speed (wpm) and/or
effective speed (a.k.a. Farnsworth), you will need "LCWO" options.

LCWO Options are listed in the help file below and demonstrated in one or more examples, I want to 
give you an over view because the combinations create very different practice material.
LCWO options are used in addition to other options.

The following names in italics, are not options and may not be directly seen in the rest
of the text but short of repeating samples of what they create, I think (or hope) they give you a 
mental image of what they will achieve. They can all also make use of other options beyond the 
LCWO ones.

I'll list the options, but not relevant values since that's in the examples.
In the following, the word "sentence" means a collection of space separated words, no punctuation 
or grammatical meaning is implied. E.g. "today tree name rig sunshine"

If math is implied below by '+' or "divide", that's done by the tool, not the user.

LCWO_slow and LCWO_fast: Alternating sentences of specified word counts, starting at a LCWO_low speed 

   with LCWO_slow number of words, and then switching to LCWO_low+LCWO_step (think increment) 
   fast speed where the length is LCWO_fast words. Optionally, you can use LCWO_effective 
   (Farnsworth), and LCWO_sf and/or LCWO_fs (both explained in examples 16 and 23). The slow 
   and fast sections alternate until the input words meet other criteria (all controlled by non-LCWO 
   options (e.g. min, max, num, etc.) are exhausted. (Optional: LCWO_effective, if used it sets the same
   effective or Farnsworth speed for both the _slow and _fast speed portions.)

   (Required: LCWO_slow, LCWO_fast, LCWO_low, LCWO_step)

LCWO_ramp: This is like walking up a ramp or staircase, LCWO_ramp enables the feature. You start 
   at LCWO_low speed for a sentence, then speed increases (by LCWO_step) after a number of words 
   are created (total words desired divided by the number of speed steps LCWO_num), increases. Ramp 
   finishes when the total desired words count and number of steps are exhausted. Optionally, LCWO_effective 
   and/or LCWO_repeat. In this behavior, the effective speed remains a constant amount less 
   then the speed.

   (Required: LCWO_ramp, LCWO_low, LCWO_step, LCWO_num)

LCWO_effective _ramp: This is like walking up a ramp or staircase, but unlike LCWO_ramp, the
   speed stays at LCWO_low for the entire session; instead the effective speed increases with each
   section. LCWO_effective_ramp enables the feature. You start at LCWO_effective effective speed
   for a sentence, than effective speed increases after a number of words are created 
   (total words desired divided by the number of speed steps LCWO_num), increases. Each new effective
   speed is LCWO_step added to the previous value. Ramp finishes when the total desired words count and 
   number of steps are exhausted.  
   This feature is help users with Farnsworth speed abilities like 20/12 move toward 20/20.
   Optionally, LCWO_repeat.
   In this behavior, the character speed remains a constant.

   (Required: LCWO_effective_ramp, LCWO_effective, LCWO_low, LCWO_step, LCWO_num)

LCWO_repeat: Functionally, this is similar to _ramp, in that it starts low and builds up, but its
   on a word-by-word basis, not sections of sentences. LCWO_repeat enables the behavior.
   It starts at LCWO_low speed, it sends one word, then the speed is incremented to LCWO_low
   + LCWO_step then the SAME word is sent again, this repeats until LCWO_num
   words of input meeting other criteria (all controlled by non-LCWO options (e.g. min, max, num, etc.)
   are exhausted. Optionally, this can be used with either LCWO_ramp or LCWO_effective_ramp (Note:
   if you use LCWO_effective with LCWO_repeat, the effective speed is not influenced by LCWO_step. 
   That is the effective speed is always the same distance below the character speed set by the difference of
   LCWO_low minus LCWO_effective. Ex. LCWO_low=20, LCWO_step=5, LCWO_effective=14 giving you what users refer to as 20/14
   (a.k.a. Farnsworth), so the difference is 6 wpm. With LCWO_repeat=3 you could get copy like: 
   "|e14 |w20 some |e19 |w25 some |e24 |w30 some |e14 |w20 word |e19 |w25 word |e24 |w30 word ...."

    NOTE: As of version 1.9, you can use a negative value for LCWO_step - the behavior change is that you will start at the highest
    speed and then decrement in steps until LCWO_low has been reached. (This is the approach taken in Morse Code Ninja Speedracer files.)

   (Required: LCWO_repeat, LCWO_low, LCWO_step)

LCWO_random: Random speed by word.  This behavior is enabled by the proper combinations of options. 
   Think of a collection of words, EACH word with a its own tag specifies its speed (and optionally LCWO_effective 
   speed, as in _ramp its a fixed amount less than the character speed), all the words are bounced around in a container 
		fmt.Println("WDL calling kicw")
   and then extracted one-by-one.  The container has one constraint, it never outputs two sequential words with the 
   same speed.  So you could get: word1@20wpm word2@12wpm word3@30wpm ....
   Speeds determined by LCWO_low, and LCWO_num number of LCWO_steps added to it. The words
   sent equals the value of option num. Optionally, LCWO_repeat means the current word will repeat
   sequentially, but each with its own speed value.

   (Required: LCWO_low, LCWO_step, LCWO_num)

   This was an overview, examples show combinations with other options.

-help LCWO gives a much abbreviated version of the above for command line use.

Note: An '*' in a delimiter string gives a half-second of silence if played in LCWO. See delimiter.

******************************************************************************************************


Example 28:
each sent word with play at a different speed

mcpt -LCWO_random -LCWO_low=15 -LCWO_step=5 -LCWO_num=3 -num=20
This example is for users of the LCWO to create MP3 files. Adding the above options (they have defaults)
to options that create "word" practice will insert on-the-fly speed changes.
In the order above the options mean: set the lowest code play speed to 15 wpm, create another speed 5 wpm higher, 
repeat 3 times. The result is that the practice text will on a word by word basis be played at 15, 20 or 25 wpm.
If delimiters are used, they play at the same speed as the preceding word. 

For example, if the options would have generated:

the and test radio end
(randomly each of those words would play at speeds shown below - a.k.a. BOUNCE)

the and test radio end
20   15 30   30    15 (indicates wpm)

Note: the actual output, looks like: |w20 the |w15 and |w30 test .... 
      LCWO.net strips the speed commands. Other software WILL PROBABLY ignore
      the "|" and send your the "wNN" in between words.

Note: the "LCWO" options are ignored if you are using code groups (-codeGroups).


Example 29:
words ramp up in speed from low to high

mcpt -LCWO_low=15 -LCWO_step=5 -LCWO_num=3 -LCWO_ramp -num=20
In this example I added the LCWO related option -LCWO_ramp. This indicates
the user wants to LCWO_ramp up speed, starting with -LCWO_low, and then increasing by
-LCWO_step after -num/-LCWO_num words were printed. In short making -LCWO_num sections at each speed.

Example output for LCWO to use as its input file:

!w15
the and test radio end ham
|w20
it of man sat house end
|w25
he the radio sat end test it of


Example 30:
create alternating section of slow/fast sending

mcpt -LCWO_low=15 -LCWO_step=5 -LCWO_slow=5 -LCWO_fast=2 -num=20
!w15
the and test radio end 
|w20
it of 
|w15
he the radio sat end 
|w20
and the

Note: LCWO_low and LCWO_step set the low speed in wpm, and the high (LCWO_low+LCWO_step)
      the output will toggle between these two speeds until -num words have been      sent
Note: the two new options LCWO_slow and LCWO_fast specify the number or "words"
      sent at the respective speeds.

      LCWO_fast can be equal or less than LCWO_low.
      Then effect of this option is to allow short bursts of higher speed to
      challenge you; then return to slower speed to recover.


Example 31:
add an audible marker for the slow/fast section as an alert

mcpt -LCWO_low=15 -LCWO_step=5 -LCWO_slow=5 -LCWO_fast=2 LCWO_sf=? LCWO_fs=/  -num=20
|w15
the and test radio end 
? ++++++++++++++++++++++++++++++ LCWO_sf string alerts to speed change coming
|w20
it of 
|w15
he the radio sat end 
/ ++++++++++++++++++++++++++++++ LCWO_fs string alerts to speed change coming
|w20
and the

Note: No checks are done on the strings given to these options.
      You can just specify one of them if desired.
      The can be the same string.
      Above I showed a single character, but they are strings, you could have used ?.? or UP DOWN etc.
      
      *** LCWO supports a "delay" in milliseconds with " |Sxxxx " where xxxx is the time. (as 
      with all the in-line LCWO options the space after is needed.)
      This could be useful used in conjunction with the alert character, like ES_sf="|S500 / |S500 ".

Note: LCWO_sf and/or LCWO_fs are the only LCWO options which may be used in a non-LWCO tutor.
      If they are specified with the option mixedMode they will frame the codeGroup 
      inserted in the output. e.g. word1 word2 XXX 3H6D?9 YYY word3 word4. Where
      XXX represents LCWO_sf, and YYY represents LCWO_fs.


Example 32:
word repetition withn the context of LCWO

mcpt -LCWO_low=10 -LCWO_step=5 -LCWO_repeat=3  -num=5
This is similar to using the -repeat option previously described, but now we will take advantage of LCWO's
speed changes. Obviously this output generated by mcpt, will become the input file to LCWO, which
is now your tutor software to create a playable mp3 file.

|w10 WOMEN |w13 WOMEN |w16 WOMEN |w10 YOUNG |w13 YOUNG |w16 YOUNG |w10 DARCY 

Note: LCWO_low=10, creates the low speed 10 wpm command "|w10" for LCWO.
Note: LCWO_step=3, causes each successive word to be sent +3 wpm from the prior value.
Note: LCWO_repeat=3, each word found repeats 3 times, each a step up in speed by +3 wpm.

Of course other options were gotten from the options file (see -optFile), or the command line (-inLen, -num, etc.)

In the following example, We added the delimiter option (previously described) to get a prosign as an audible 
clue that the speed was going to drop back for the next set of words.

|w10 HURST |w13 HURST |w16 HURST <SK> |w10 DARCY |w13 DARCY |w16 DARCY <BT> |w10 YOUNG |w13 YOUNG

To get this I added to the command line (or options.mcpt.: -delimiter="<SK>|<BT>" -delimiterNum 1

NOTE: As of version 1.9, you can use a negative value for LCWO_step - the behavior change is that you will start at the highest
      speed and then decrement in steps until LCWO_low has been reached. (This is the approach taken in Morse Code Ninja Speedracer files.)


Example 33:
start LCWO session with a header for options to apply to entire session
(option footer puts verbatium data at the end of output)

mcpt ... usual options choices ... -header="|W3 |f600"
The output is inserted, verbatim before any generated output.

Note: No checks are performed on the content of header, its passed to your 
      tutor for evaluation.
 
      A good use of this is to set multiple LCWO related options. The command above
      would increase the inter word space by 3 times normal spacing; and set the tone 
      to 600 HZ. So no quotes for LCWO use or the
      option will NOT take effect. Since an LCWO option sequence MUST be followed by a space between
      the option and text, mcpt will add one trailing space. (e.g. -header="|f660 |w20"  would
      create output like: |f660 |w20 word1 word2 etc. (note the quotes are needed because the string 
      contains a space.)

***** The following, examples combined general and LCWO options. *****


Example 33-A: 
LICW special usage of the <tutor> and <lesson> options

In this section greater than and less than symbols are used to show an item is an option i.e. 
<tutor> or a value, they are NOT typed.


The Long Island CW Club, has a revolutionary approach to teaching their chosen characters for CW. 
Their online documentation describes this "carousel" (circular) approach. This is very different 
from a usage and programming stand point, so I have provided much more detail on the use of these two options.
.P
During run time, users will not likey need to refer to this level of detail,
but can get what thye need by running: mcpt -help=LICW.
.P
To give the user, the most flexibility, there will be 4 values of the <tutor> option, where as other tutors have only one.
.P
*** This sounds complex, but its not, look at the lines with "mcpt" and the output ***
*** then the details will be easy, maybe unnecessary.                              ***

If you are NOT an LICW user, you will likely use -help=tutors to get the lesson
concept for other tutors, or see the <cgList> option for the non-structured approach.

If you are here, you know the carousel has a BC1 and BC2 (begineers corousel 1 or 2), to divide the characters 
into two sets. For the <tutor< however, you will use BC1S, BC2S, or BC1C, BC2C.

The suffix "S" or "C" is for "mcpt" to give the user "session" or "character" granularity of accessing the characters (details follow).

Using the "S" suffix, the characters are by the entire SESSION, that is
for example you can get practice material such as code groups, or words, based on
"REA" or "REATIN", but you CANNNOT suppress a character to get "RE" (its the entire session).
This maybe fine, doesn't let a user get practice like "RR RRRR R RRRRR".

If you want acccess at the CHARACTER level, you would use a "C" suffix, i.e.
BC1C
Both are just should hand notation for a more general option <cgList> (for code group list) where you can do ANYTHING regardless of the clubs teaching order.
An example would be "-cgList=RB16M" having rome characters from both BC1 and BC2.

Now let's look at how to get to the characters you want, within the concept of 
SESION or individual CHARACTERS. This is done with the <lesson> option values.
MCPT will use an ID as an identifier or index to the values you want, note
these are for this tool's purpose, an LICW instructor is not going to know what you mean if you saying "I'm doing ID 4".


First, the simple cases.

<tutor> will be "BC1S" or "BC2S" (for lessons at a SESSION level, like "REA").
<tutor> will be "BC1C" or "BC2C" (for lessons at a CHARACTHER level, like "RE" or "R").

The <lesson> does not use the suffixes above.

If you want code groups from all the characters in the B1 carousel:

run: mcpt -codeGroups -tutor=BC1S -lesson=BC1 (** see note)
	output is like: RTEEI BEAAU GPFW .....  
	           add: -cgLen=2:4, for example to have group lengths from 2 to 4, 
	output is like: EEI AU GPFW TE UB OHHN .....

	To get all the characters of BC2, use: tutor=BC2S -lesson=BC2 (** see note)

For ALL the LICW taught characters, use -tutor=BC1S -lesson=BC1:BC2 (** see note)

	NOTES: - the <lesson< option has NO spaces, 
	       - the separator is a colon (when needed),
	       - the letters are not case sensitive.
	        - ** Since the >lesson< value was for ALL characters, the  could
		  use either the "S" or "C" suffix.

 NOTE: The suffix is NOT used in the lesson, becasue whether BC1 or BC2 in the lesson, you are already indicating the ENTIRE set,

The more common case is to limit the training to only those taught by a carousel session,
for example "LCD" or "KMY", (As preiously stated, you can get ANY set without using the 
tutor/lesson pair of options, by instead using the <cgList> option, 
like: mcpt -codeGroups -cgList="ABC123?<SK>". 

The tutor and lesson simply prepopulates the <cgList> option behind the scenes.

How does a user who get practice for a particular session? 
A sequence ID or a pair of them based on the listings at the end of 
this help determines the character. 

If the teaching session was for BC1 characters "HOF", for example, look at the BC1C table to find IDs
for H, O and F, they are 13, 14, and 15. Use them in the <lesson> option 
as follows (also sample output is shown):

	mcpt -codeGroups -tutor=BC1C -lesson=13:15 -cgLen=3    (## see note)
	     OUTPUT: OOF HHO FOF OHF FFF
	mcpt -codeGroups -tutor=BC1C -lesson=13:14 -cgLen=5    (** see note)
	     OUTPUT: HHHHO OHOHH OOHOH OOOOH
	mcpt -codeGroups -tutor=BC1C -lesson=14 -cgLen=2:5     (** see note)
	     OUTPUT: OOO OO OOO OOOO OO OOOOO OOO

	(Note: tutor names are not case sensitive.)
	(Note: Option NAMES must be as shown).


	Note:
	      - ## Since the lesson 13:15 was the entire 3 character session the alternate command 
	        that follows does the same thing:
		mcpt -codeGroups -tutor=BC1S -lesson=5 -cgLen=3
              - ** this command is selecting LESS than the 3 characters of the
	        session. Its the key differnece between "C" and "S".

The ID is the start and (if given) the end of the range. In the table character sequence 
repeats (denoted by an *), this allows the no-reset concept of the carousel. A user that jumped 
on the carousel at "HOF" (ID 13-15) would progress to ID 30 in order to cover all of BC1.


	mcpt -codeGroups -tutor=BC2C -lesson=BC2
	     OUTPUT: groups with ALL BC2 characters
	mcpt -codeGroups -tutor=BC2C -lesson=<start ID>:<end ID>
	     OUTPUT: character from start ID to end ID of BC2

	mcpt -codeGroups -tutor=BC2C -lesson=BC1:<ID>
	     OUTPUT: ALL BC1, plus only one CHARACTER from BC2
	mcpt -codeGroups -tutor=BC2S -lesson=B1:<ID>
	     OUTPUT: ALL BC1, plus only one SESSION from BC2

	mcpt -codeGroups -tutor=BC2C -lesson=B1:<ID>gt;ID>
	     OUTPUT: All BC1, plus a set of BC2 CHARACTERS
	mcpt -codeGroups -tutor=BC2S -lesson=B1:<ID><ID>
	     OUTPUT: All BC1, plus a set of BC2 SESSIONS

 Use these columns for              Use these columns for
 CHARACTER level access             SESSION level access 
 i.e. 3="A"                         i.e. 1="REA"
 -tutor=BC1C or BC2C                 -tutor=BC1S or BC2S<\B>
 ===============================    ===============================

 ID    BC1        ID   BC2          ID    BC1      ID    BC2
 ==    ===        ==   ===          ==    ===      ==    ===
 1     R          1    K            1     REA      1     KMY
 2     E          2    M            2     TIN      2     59,
 3     A          3    Y            3     PGS      3     QXV
 4     T          4    5            4     LCD      4     <AR><SK><BT>
 5     I          5    9            5     HOF      5     16.
 6     N          6    ,            6     UWB      6     ZJ/
 7     P          7    Q                           7     28 BK
 8     G          8    X                           8     40 (zero)
 9     S          9    V
 10    L          10   7
 11    C          11   3
 12    D          12   ?
 13    H          13   <AR> or +
 14    O          14   <SK>
 15    F          15   <BT> or =
 16    U          16   1
 17    W          17   6
 18    B          18   .
 19    R  *       19   Z
 20    E          20   J     
 21    A          21   /
 22    T          22   2
 23    I          23   8
 24    N          24   BK
 25    P          25   4
 26    G       *  26   0 (zero)
 27    S          27   K
 28    L          28   M
 29    C          29   Y
 30    D          30   5
 31    H          31   9
 32    O          32   ,
 33    F          33   Q
 34    U          34   X
 35    W          35   V
 36    B          36   7
                  37   3
	          38   ?
                  39   <AR> or +
                  40   <SK>
		  41   <BT> or =
		  42   1
		  43   6
		  44   .
		  45   Z
		  46   J
		  47   /
		  48   2
		  49   8
		  50   BK
		  51   4
		  52   0 (zero)

|W15 |W10 DK6HF |W15 KILLJOYS OUTSPOKEN |W10 AT.,3 |W15 RESALE WASPISHLY |W10 L98G4
|W15 TWIG BALLYHOO |W10 XUNCR |W15 UNDERBODY SAPPED |W10 BQMS? |W15 ROSIER SEMAPHORES
|W10 Y2O1V |W15 SENIOR PARALLELS |W10 J7/IZ |W15 IM 

Note: the code groups are sent at 10 wpm, while plain text words are at 15 wpm.
Note: ignore the double speed option at the start, LCWO will work correctly.

This example combines about 80% of the available options, including many of the LCWO options.
All defaults are overridden for demonstration purposes. The intent is to show flexibility of the
tool, not that this combination would necessarily be used by many people. As stated before,
EVERYTHING is optional, so look at the functionality not on the specific content (words, characters,
ProSigns, lengths, etc. they are all configurable).

The input and output are kept short here, for actual practice the user
would most likely specify much larger sizes.

First, I'll explain the three files utilized to create the output, then we'll look at how the LCWO
options instrument the file so that LCWO can perform on-the-fly option changes.

**** below is the input file  **********
the quick brown fox jumped over the lazy dogs back

**** below is the prosign file  *****
<AS>
<BT>
<HH>

**** below is the options file  *******
**** line numbers are NOT part of the file, they are for the notes that follow
     1	in=demo.txt
     2	prosign=prosign.txt
     3	out=fileToGiveLCWOToPlay
       
     4	inlist="A-Ya-y"
     5	inLen=3:5
       
     7	num=11
     8	len=60
     9	ordered
    10	
       
    11	cgLen=5:5
    13	cgList="a-z0-9,.?/=@"
       
    14	repeat=2
       
    15	mixedMode=3
    16	MMR
       
    17	preLen=1
    18	preList="012"
    19	sufLen=2
    20	sufList=".,"
    21	random
       
    22	DM=3
    23	delimiter="?^/^<SK> ^QTH "
    24	delimiterRandom
       
    25	#END
       
    26	header=|f650
       
    27	LCWO_ramp
    28	LCWO_repeat=3
    29	LCWO_num=4
    30	LCWO_low=20
    31	LCWO_step=5
    32	LCWO_effective=18
    33	LCWO_sf="|s400 |f1500 T |f650 |s400"
       
******* end of file
1,2,3	Input file of potential words to be used; prosign file already listed, output file to give to 
        tutor program.
4       The characters an input word may contain or else its discarded. Note they is no "y", so the word "lazy" is
        discarded.
5       The minimum, and maximum length of an input word, or its discarded. Note "jumped" is longer than 6, 
        so its discarded.
7-10    Some global options. Num limits the words in output (note a sequential repeat of a word is not counted).
        The output line len, is approximately this long unless it would split a word.  Ordered means the input 
	words are Not-Randomized, so they are in the order they were found unless there were discards.
11-13   Are for code groups. In this example, the code group is created because of the mixedMode option. 
        The lengths for min and max are the same so the code groups are fixed size. The characters in a code 
	group are not related to any other list option.
14      Each "word" that passes the filter criteria of: min, max, and inlist, will be shown twice. 
15,16   MixedMode means the user wants a code group mixed in with words read from file. Here the 3 means a 
        code group will appear after every 3 words - normally. But MMR, indicates that the behavior is 
	randomized, so you could see multiples of 3 words without a code group.
17-21   Prefixes and/or suffixes may be added to words (note prosigns randomly replace a word, therefore 
        they can get a prefix or suffix. The number as in sufLen=1:2, means the word gets from 1-2 characters 
	added. The sufList and ist are the possible characters (they are limited and different in the 
	example to easily see the effect.  The final option random, means either could be suppressed on any 
	given word. Note that a space is a viable character, so it could make random character(s) just before 
	or after a word.
22-24   Delimiters are strings that delimit or separate words. The list of values are separated 
        by "^". If DM is greater than 1 (DM - delimiter multiples), between 1 and the DM value of fields 
	from the delimiter list may be concatenated together (spaces are supported). delimiterRandom means the appearance 
	is random.
25      The #END stops the reading of the options file.

The remainder of the options will be discussed below.

***** Below is the practice text generated which does NOT use any LCWO features, I'll add them shortly.


0THE 0THE <SK> QUICK QUICK QTH <SK> 2BROWN 2BROWN QTH ? 0<AS> 0<AS> FOX FOX ?<SK> k0OVER 0OVER
?/<SK> 0THE 0THE <HH> <HH> <SK> /  DOGS. DOGS. ? 0BACK,. 0BACK,.  QTH  THE THE QTH <SK>  


Comments:

So you can see the words: THE, QUICK, BROWN, FOX, and OVER, are from the in file, in order.
<AS> and <HH> were from the prosign file, they are treated as words. They were randomly injected 
into into the word flow.
`
Note "lazy" and "jumped" were discarded for length or character make up respectively.

THE, BROWN, <AS>, and OVER got a prefix character added (prefix length=1) and its one of the characters in 
list (012).

QUICK and FOX got neither a prefix or suffix because the random option was set.

DOGS and BACK got a suffix, 1 or 2 characters (suffix length=2) from sufList (,.).

BACK got both a prefix and suffix.

Every other word is separated by a delimiter string, you see , /, QTH. Since the delimiter random 
option delimiterRandom is set, sometimes it was suppressed.

All the "words" are duplicated due to the repeat=2 option.


Now lets go back to the options file, assume the #END line has been removed, leaving all the options as above,
lets add as many LCWO options are possible. The output will be much more complex (thankfully without any need
for typing) and allow LCWO.net to give us on-the-fly changes to speeds (character and effective, tones, etc.)

26	The header |f650 tells sets the audio tone in HZ. (it will override the browser setting).
27	Set the _ramp feature, character speed will increase throughout the session.
28 	Repeat sets a second simultaneous feature which repeats EACH word at a higher speed, until the 
        ramp speed increases. Since it's 3, each word is played at 3 speeds.
29      Num specifies how many speed changes in the ramp from the start until the end of the session.
        The number of words at each ramp speed is the total num/LCWO_num (don't worry about the math errors 
	in values are flagged).
30      The lowest or starting character speed in wpm is set by LCWO_low.
31      LCWO_step is the number of wpm to increase the speed by in each ramp up.
32      LCWO_effective indicates the user wants effective or Farnsworth timing. The 
        delta between LCWO_low and LCWO_effective is maintained as the ramp or repeat speeds change.
33	An optional alert tone (1 dah) is played before each change in ramp speed. The alert could just be text,
        but this sequence tells LCWO to: sleep for 400 ms, change frequency to 1500 HZ, play a "T" (dah), then 
	revert to the cw tone of 650 HZ, and finally sleep (or place silence 400 ms).


What does this look like? The file is below. Since its wrappers around what we had above I'm not going to 
bore you with the item by item description. You can see the character speeds set by |wNN, and the effective 
speed by |eNN. |fNN is the audio tone.

You can cut and paste the text below into LCWO to hear it, even with out using mcpt. You can use guest 
credentials, test/test to login if you don't have login credentials of your own (it goes into the 
"Convert text to CW" screen).

Just to point out a few effects of the LCWO options:

|w20 is from LCWO_low, the starting character speed wpm
|e18 is from LCWO_effective the starting effective speed. In the rest of the session the effective 
speed stays 2 wpm less than the character speed.

Words are sent 4 times, twice as explained above due to repeat, then again at increased speed 
from LCWO_repeat=2.

The entire word repeat and speed repeats are within the _ramp progression, building from 
LCWO_low wpm through LCWO_num speed increments of LCWO_step size.

**** below is stored in the output file specified by out=, in the options file.

|f650
|w20 |e18 0THE 0THE |w22 |e20 0THE 0THE <SK>  |w20 |e18
QUICK QUICK |w22 |e20 QUICK QUICK QTH <SK>   |s400 |f1500 T |f650
|s400|e18 |w20 |w22 |e20 2BROWN 2BROWN |w24 |e22 2BROWN 2BROWN
QTH ? |w22 |e20 0<AS> 0<AS> |w24 |e22 0<AS> 0<AS> |s400 |f1500
T |f650 |s400 29,RJ  |s400 |f1500 T |f650 |s400|e20 |w22 |w24
|e22 FOX FOX |w26 |e24 FOX FOX ?<SK>  |w24 |e22 0OVER 0OVER |w26
|e24 0OVER 0OVER ?/<SK>   |s400 |f1500 T |f650 |s400|e22 |w24
|w26 |e24 0THE 0THE |w28 |e26 0THE 0THE |w26 |e24 <HH> <HH> |w28
|e26 <HH> <HH> <SK> /  |s400 |f1500 T |f650 |s400|e24 |w26 |w26
|e24 DOGS. DOGS. |w28 |e26 DOGS. DOGS. ? |w26 |e24 0BACK,. 0BACK,.
|w28 |e26 0BACK,. 0BACK,. QTH  |w26 |e24 THE THE |w28 |e26 THE
THE QTH <SK>  

When using LCWO_ramp with and without LCWO_repeat, if num is not significantly larger than LCWO_num, you will
have a very steep ramp (a.k.a. fast changes in speed). This is amplified if you combine it with LCWO_repeat
with a large value. So start out with small values for LCWO_step, LCWO_repeat until you see what's generated.

-help=LCWO  should summarize the interactions without the need to refer to the user guide.

**** mcpt -help=LCWO is shown below.

Relationships and compatibilities for LCWO Options

Option names starting with "LCWO_" are only for users that will input the generated practice text
to LCWO's "Convert text to CW" screen.

Other non-LCWO options can be used as well.

LCWO_slow: (alternating slow/fast word groups)
		requires: LCWO_slow, LCWO_low, LCWO_fast, LCWO_step
		optional: LCWO_sf, LCWO_fs
		incompatible: LCWO_ramp, LCWO_effective_ramp, LCWO_num, LCWO_repeat

LCWO_ramp: (steady increase of character speed sections of words)
		requires: LCWO_ramp, LCWO_low, LCWO_step, LCWO_num
		optional: LCWO_sf, LCWO_repeat, LCWO_effective
		incompatible: LCWO_effective_ramp

LCWO_effective_ramp: (steady increase of effective speed sections, with fixed character speed)
		requires: LCWO_effective_ramp, LCWO_low, LCWO_step, LCWO_num, LCWO_effective
		optional: LCWO_sf
		incompatible: LCWO_ramp, LCWO_repeat

LCWO_repeat: (each word repeated at increasing character speeds)
		requires: LCWO_repeat, LCWO_low, LCWO_step
		optional: LCWO_effective, LCWO_ramp (LCWO_num if LCWO_ramp)
		incompatible: LCWO_effective_ramp

LCWO_random: LCWO_low, LCWO_num, LCWO_step (no other LCWO options): (each word has random character speed)
		requires: LCWO_low, LCWO_step, LCWO_num
		optional:
		incompatible: LCWO_effective_ramp, LCWO_ramp, LCWO_repeat, LCWO_slow, LCWO_fast, 
		LCWO_sf, LCWO_fs

Note: LCWO_sf and LCWO_fs MAY be used outside of LCWO. If used with option mixedMode,
these will insert the specified string immediately before and/or after the codeGroup.

If LCWO_low and LCWO_step, are used with both the options  and , then plain text is sent at the 
faster speed of LCWO_low + LCWO_step, while the codeGroup (due to mixedMode) will be sent  at the slower speed of LCWO_low.

The concept of this combination of options, is to give you a means of
listening to practice session of words to build up your ICR (Instant Character Recognition) and simultaneously begin to develop IWR (Instant Word Recognition).

Initially, your IWR word list would be only a word or two that are very short
like "the" or "and". The speed to hear these words at should be higher than
what you are practicing the other characters at, so that you will begin
to hear the IWR word as have a unique sound rahter than it being a series of
letters to make a word.
The sample option file below, explains the few required and optional options
to use this feature. You can of course type the options on the command line
or use an optFile as you like.

#
# this is a sample optFile to use instead of entering the options
# on the command line
# in this case this file has been named "opt.txt"
# to run, enter: mcpt -opt=opt.txt


# this opt names a text file that contains the "words" you want
# to learn as IWR (Instant Word Recognition). The format of the file is:
#
# 1 word per line! (spaces can be before or after the word)
# the word can be upper or lower case
LCWO_iwrFile=wd.txt

# inFile or textFile is the file of words to play
# for example some pages from a fiction book
inFile=in

# this is the WPM to play any words from LCW_iwrFile, which were found in
# the input file (inFile or textFile)
LCWO_iwr_wpm=25

# num is how many "words" to put in the output.
# ZERO is a special case, it means ALL the words that match!
# If you input had 10 words that meet the criteria (explained below)
# and you have num=50, then the output would repeat the same 10 words
# to get to 50.
num=0

# this means keep output in the same order as input (not random)
# This is REQUIRED for the IWR feature!
ordered

# this is the lowor normal speed of the characters that were NOT matched
# by the IWR file
LCWO_low=15

# this is the Farnsworth spacing speed, it MUST be lower than LCWO_low (if 
# its used. 
# Farnsworth is NOT required, and is NOT used for the faster IWR words.
LCWO_effective=10

# The "words" in the iput file MUST meet 2 criteria to not be filtered out.
# The word length must be met. Given by inLen=1:12 (for example, meaning
# words with 1-12 characters).
inLen=1:12

# inList, is the characters that a "words" can have without being 
# filtered out. The default is all 26 letters, use the option for less; or
# use lesson=X where X is the lesson number you are at in LCWO.
# See the LCWO GUI or run: mcpt -help=tutors, and look at the LCWO column.
# FYI inList if used with inFile (not textFile) can have digits, prosigns,
# or .,?/
inList=A-Z

# outFile is a file name for the output. This is the file you use
# in LCWO's "Convert Text to CW" screen, to play code or make an MP3 file.
outFile=out.txt

# Lastly - Only the Tone setting on the LCWo screen will has effect, the 
# speed is set in the file based on options above.


Contact me at: [email protected].