This tool creates practice text that can help with Instant Character Recognition (ICR), improving your brain buffer ability, and ultimately Instant Word Recognition (IWR). It creates a uniquely formatted text file to use in conjuction with a text-to-cw morse code audio program.
Instead of using canned input files, the user will create a file with words they would like to learn. In most cases, candidate words are common words found in QSO's, such as: common nouns, prepositions, standard CW abbreviations, and Q-signals (e.g., name, the, and, for, on, as, QSO, QSL, state abbreviations, and ProSigns.)
The tool does NOT verify or limit what is considered to be an input words, with valid ProSigns being an exception.
The main feature is the splitting of a randomized selected words from a text file (e.g., 'TEST'), and presenting the word as a set of strings, building the word in a character-by-character fashion: T TE TES TEST. You can see that this is some ICR, brain buffer training, and finally the full word for IWR. Adding a preview option (e.g., -p=1) and/or a repeat option (e.g., -r=2), can expand output such as: TEST T TE TES TEST TEST TEST.
Single characters can be practiced as if they were an entire word (e.g., A, T, V, ?) ProSigns also can be used without being split into pieces. (Full words or strings can be intermixed without being split, as discussed later.)
Alternately, the tool can simply randomize any words or strings (without split format) for normal code practice.
A brief help is available with: wordSplit -h.
A Windows or Linux PC to match the appropriate download.
An app which can either read a text (.txt) file for input, or has a means of accepting a cut-and-paste of data.
An app that can keep the text in the order received when it creates audible CW.
All of the following apps can work with this tool, and likely many more.
LCWO.net, use Convert Text to CW feature
Precision CW Tutor, use Read text to memory (Ctrl-T)
LICW.org's Practice Page, use Insert File in the top panel
Morse Elmer (phone app), Use file input
Download the appropriate binary.
Place the file in a directory which is in your PATH. (or prefix wordSplit with ".\" or "./" as appropriate for Windows or Linux respectively).
Run the program from your terminal or command prompt using the options described below. (Linux shell, Windows CMD window (Windows Key+R cmd), PowerShell) An alternative to putting options on the command line is provided.
The are NO configuration or setting changes required to your PC.
The options below are demonstrated in the examples.
-f <file> Required: File containing "words" to practice -n <number> Optional: Number of words to process (0 to 5000). 0 means all in the -f file. -r <number> Optional: Number of times to repeat the full word after it's spelled out (0-5), default 0. -s <separator> Optional: Separator between split word output. Default is none. -p <number> Optional: Number of times to preview the word before spelling (0-5), default 0. -o <output> Optional: Output file. If not given, output is printed to screen. -R <t or f> Optional: Final review — vvv <KA> followed by unsplit words and <AR>. Default false. -h Optional: Show help regardless of other options.
Options can be specified in a file called "wordSplitOptions.txt", instead of on the command line to save repetitive typing. If the file exists, options are first read from the file, but if also put on the command line, the command line value takes precedent. The options file is a simple text file created with: notepad, vi, vim, emacs, etc. not a word processor like wordpad, MSword, etc..
The options file, as well as the -f word file share the following features:
blank lines are ignored
all spaces at the beginning and end of lines are trimmed off
after space trimming, a line that starts with "//" or a # is for an optional user comment and is ignored; it can also be used to temporarily ignore a line
OPTIONS FILE: Each option must be one its own line; its format is the same as if
it were typed on the command line.
The followings is an example wordSplitOptions.txt file showings all the formats that can be used. (Users with programming
backgrounds usually have a preference.) Also the comments may be useful.
// this is one a comment style, the entire line is ignored
# this is an alternate comment style, the entire line is ignored
# these formats apply to options with integer values (e,g,, -c, -n, -p, -r)
-p=2 # note this is an end of line comment. the minus is REQUIRED on the cmd line, but OPTIONAL in the file
p 3
p=3
# -f and -o are file name option; they are strings, on cmd line double quotes are wise to use. Here optional.
-f=myWords.txt
f=myWords.txt
f="myWords.txt"
# -s is the separator option. Often may be Prosigns or have spaces. USE quotes!
-s="<BT>"
s=".|?|,|the end" # The | means OR, so you get 1 or those 4 values
s=? # works here, but cmd line could be an issue - USE quotes!
# -R is a boolean (true/false) type option it is both "off" by default so there is no real reason
# to explicitly set the to false, but I'll lsi them anyway.
-R # YES no value is needed
R # same as above
R=1
R=true
R=T
R TRUE
R=t
-R=false
R false
R=False
R=0 # that's a zero
# NOTE: values of ON/OFF, YES/NO regarless of case are NOT supportted in this language.
The -f option is required since it
specifies the "words" of interest. Lets cover the aspects
of this file before we see it in use in the examples section.
All other lines are examined for candidate words. There are two types: split-words, and non-split words, as defined below:
A split word is longer than 1 character, is not a ProSign, cannot contain a space, can not start with '#' or '%'. Here are examples of valid and sensible split-words: name, the, and, rst, dipole, QSO, qrs, 73.
So here is the word "hello" in the "-f=myWords.txt", being split: h he hel hell hello. This demonstrates some ICR, ending with IWR, after some brain buffering practice. The IWR can be further emphasized with the options -p and -r, shown in the examples.
A non-split word is a single character (one way to get ICR practice), any valid ProSign or string of ProSigns, a word that starts with '#' is ignored.
A '%' can be placed at the start of a word (longer than 1 character and not a ProSign), which you want to use as any normal practice word (i.e. non-split. It's also a way to transition from a split word, to a non-split word as you become proficient in head copy or IWR of a word.
Here are two sample formats for a word file, with lots of // comment lines. // This is a comment so it's ignored // The next line is blank so it's ignored // the next "word" is ignored becasue of the '#', // but not the rest of the line if there are more words. #skipped // following is the preferred way to list words in the '-f file' name rst qso DIPOLE // the following are only 1 character long so not split, therefore just ICR practice I A ? / // the following are used as non-split %hello %worls <SOS> <BT> // ALTERNATE format of the above but no comments. (My opinion less readable). #skipped name rst qso DIPOLE I A ? / %hello %worls <SOS> <BT>
By default, output is sent to the screen. If you want to save output to a file (most likely case), use '-o file.txt'
Output is in the same case as the characters in the word file, use what your CW app requires.
WordSplit has no knowledge of CW or any particular app; it will use whatever characters you supply. Its up to the app to discard characters that it does not support.
ProSigns in the form of <XX> are checked for validity, Supported ProSigns are: <AR>, <AS>, <BT>, <DU>, <HH>, <KA>. <SOS>. <SN> or <VE>, <SK> or <VA>. <BK> format can be used, but it is printed as " BK " since it is not a ProSign.
Output is in a line-by-line format for ease of checking, however apps will see the data as a continuous stream. The separator option '-s' may be of use here.
In each example, the command is shown in bold followed by output to the screen. The simple header will only be shown in the first example; it's written to the screen. All the examples below will output to your screen. In actual use its much more likely you will add the output option '-o' with a file name to give to your CW app. e.g., wordSplit -f=in.txt -o=out.txt.
All the following simple examples will use the trivial word file (words.txt) below: The output will be ABBREVIATED to show just the main point of each example. You should go through the examples in order.
// this is words.txt qso name test I <SK> ?
Using ALL default values. (-f think File) wordSplit -f=words.txt wordSplit v1.0 by WA2NFN test t te tes test test I <SK> qso q qs qso qso ? name n na nam name name // The simple header printed. // The word randomly selected first was "test". I was printed once because the // preview option defaults to 1, i.e. -p=1 // The word is split, and output in strings buidling from the first character // 't' and growing until the full word is printed. // Notice the full word was then printed once more; because the // repeat option defaults to 1, i.e. -r=1 // Next you see "I <SK>", they were the next 2 words found, they are no-split // words, so they are used as is. // The last thing to note is that each word was only used once; this is because // one more option -n=0 is the number of words to act on. ZERO is a special case // meaning each word in the file once.
wordSplit -f=words.txt -r=2 (abbreviated output) n na nam name name name name // With -p=0 (the default) there is no preview of the word. No hint, we have characters and // immediately have to buffer until the full word is printed. // With -r=2, the full word is repeated 2 more times.
wordSplit -f=words.txt -r=2 -n=10 (abbreviated output) q qs qso qso qso n na nam name name name n na nam name name name t te tes test test test <SK> I I ? ? <S>K // The only change from the previous example is setting // -n=10 (n meaning the number of words to select). // Since the file had less than 10, some words will be // used more than once.
This example shows the '-R' option (one of two uppercase options), meaning REVIEW. After output has fulfilled the quantity of the '-n' option, doing splitting or not as required, you get a brief review of the words as they are found in the '-f' file (less any % characters). There is also a simple use or 2 prosigns, as follows.
vvv<KA> qso test I name ? <SK> ....... <AR> // default of -R is false, i.e., to not have a review
Above I mentioned to not be misled by the line like appearance of output, that's because your CW app will treat the line ending as a space. For example, this simple output below:
test t te tes test word w wo wor word // Will appear to the CW app as: test t te tes test word w wo wor word.... // The separator option '-s' can give your brain the clue that a new word is coming. // Below is an example with a ProSign as the separator. wordSplit -f=words.txt -r=1 -n=10 -s='<BT>' (abbreviated output) q qs qso qso <BT> t te tes test test <BT> n na nam name name <BT> // So again, the app sees: q qs qso qso <BT> t te tes test test <BT> n na nam name name <BT> // We can even let wordSplit randomly choose from a list of separators to minimize anticipation, // or give some variety of IWR practice. // Below is the output using a 3 part separator: -s='<BT>|?|. ,' // See the notes from wordSplit -h about the use of quotes in options, // and also using the '/' slash (stroke or slant) character. q qs qso ? t te tes test . , n na nam name <BT> Or in reality q qs qso ? t te tes test . , n na nam name <BT> // Note in the case of the last field the separator of ". ," has a space, and its yet another way // to get a little ICR practice.
The '-R' only provides a small quantity of all your words in the '-f' file for review, a simple alternate way to get randomized words or strings is described below. This may also be useful in case your CW app does not have such as feature.
To randomize all of your words, put a '%' in front of every word in your input file. Run with the command shown.
%qso %rst %name %qrs? %<SK>wordSplit -f=words.txt -n=20 qso qrs? rst qso qso qrs? rst qrs? <SK> qso <SK> name name <SK> rst qrs?
To randomize all of your words, put a '%' in front of every word in your input file. Run wordSplit with the -f and -n options.
The '-c' takes a count of characters from 1 (the default) to 9. In all previsous examples, the default was used, so when a word was split (remember a word had to be longer than 1 character and not be a ProSign) like: test, we had "t te tes test". So the -c=1 is why we got a single letter, and why with each subsequent chunk was 1 character more. It should be logical that if -c=2, we would have gotten: "te test". since 2 sets of 2 finished the four letter word.
Let's look at a few cases to clairify a few points. Using the default for preview (-p=0) and repeat (-r=0). Let's have the following words in our data file, as split-words (no % sign preceeding the word): as, his, them, themselves.When "as" is selected, or "his", they are output as is, not split becasue their length is less than or equal to 3 (-c=3).
When "them" is selected, it is longer than 3, so it is split in two chunks of 3 or less i.e., "the them" (them being 3 for "the" + the leftover "m").
When "themselves" is selected, it is long enough to be split into 4 chucks or 3 and one left over, so the output is: "the themse theselve themselves".
Hopefully you see the brain buffering gets more challenged as the value of -c is increased. (A stretch goal.)
This may seem like overkill of an explanation, but the reason is so you're now confused about the output when the word length is less than or equal to -c, and you specified -p and/or -r with nonzero values.
We just justified "his" or any 2 or 3 letter word simply printing as itself, even if it was a split-word, but preview outputs the word 0-5 times BEFORE the splitting, and repeat 0-5 times after the splitting. So adding -p=2 and -r=1, we get the following output (bold is the effect of -p, plain is the word, and italics is the effect of repeat. his his his his. So quite a bit of headcopy practice of a simple word.