Morse key design thoughts

[BreakingOhmsLaw]

So I've set my mind on getting the (now optional) Morse certification along with my HAREC license as quite some European countries like France, Luxembourg and Spain still require this for a "full" license.
As I understand, you can bring your own Morse key of choice to the exam.
Straight keys are widely available on Evilbay, the electronic ones not so. So, of course, I am brewing my own.

What I understand from what Google coughs up, most of these designs have a potentiometer that sets the WPM dit/dah speed in the correct 1:3 duration. Some have a second pot to set the pause to a different WPM speed, which is neat for practicing.

Now, the the sequence for a J (· − − −) can never be followed by a dit, as J can only progress into a "1" (· − − − −) or " ' " (· − − − − ·). Both follow that with a dah. So do more recent designs take this into account and filter out an erroneous dit? Does it even make sense to implement this kind of plausibilization? As morsing at higher speeds is pure muscle memory, and an automatic correction is hardly feasible, it seems kind superfluous. Of course I could administer an electric shock to the user for each error  to "enhance" the learning experience 

[geggi1]

If you are going to build a morse key you will find a lot of examples on tie internet. Just google and you will find.
I guess it is simplest to bild a straight key or possible a side trow key similar like the vibroplex.

If you are going to build a keyer (memory keyer) i have seen plenty of exsamples based on arduino. Arduino is probably the simplest and cheepest way to build the keyer.

[emece67]

.

[fourfathom]

Does it even make sense to implement this kind of plausibilization?

I think you're saying that you want to build an electronic keyer, and wondering if adding some sort of error detection would be a useful idea.

This is an interesting concept, but what do you do when you detect an invalid dot/dash sequence?  I doubt that you would want to just truncate at the first error and wait for a space before resetting.  You might emit the "error" code (eight dots in a row)?  But I don't think this is particularly useful.  I've only ever used a manual straight key (used to do 20 WPM back in my youth), but I don't think I would like any sort of automatic error detection.

[joeqsmith]

I used to get a magazine I think named 73 (8.5X11 half inch thickish).   The reason I liked it, it had various projects for the beginner, one was an auto identifier which I built.  Sorry but it was lost over time but I remember it using a series of 7400 counters that would scan a 4148 diode array (the PROM if you will) into some decode logic.   You would hard wire the diode array for your call sign.   It was a fair bit of hardware for what today would be one small PIC.

I had an Vibroplex which I still have today.  I showed it at the beginning of the attached video.   It's pretty fast in the right hands.   The magazine had an article about writing software to decode Morse code with a computer.   I decided to attempt to recreate it on my own computer.  Unlike the article,  I had the ability to transmit as well as receive.   The receive would track the speed of the sender.   Here is the section of code that detects if its a dash or dot. 

Keep in mind, this computer predates the microprocessor.   



    *
    * SEGMENT USED TO RECV IN MANUAL
    *
    SEG   ENDSRCH
    STARTUP  CLC                 POSITION CURSOR
             LDI   1
             MAL
             LD    BUFF+1        RESET BUFFERS
             ST    KPOINT+1
             ST    PPOINT+1
    WAITZZ   LDI   X'00'         RESET MARK/SPACE COUNT
             ST    CHRCNT
             JSR   VLDMKQ        LOOK FOR A VALID MARK
             LD    CHRCNT        WAS THERE A VALID MARK?
             CJEQ  X'01',WAITZZ  IF NO CHECK AGAIN
    NEWMKQ   JSR   MKTYPQ        DASH OR DOT?
             LDI   X'00'         RESET MARK/SPACE COUNT
             ST    CHRCNT
             ST    CHRCNT1
    SPTYPQ   JSR   VLDMKQ        IS THERE A VALID MARK YET?
             LD    CHRCNT
             CJNE  X'01',NEWMKQ
             LD    CHRCNT1       ACC =2*CURRENT SPACE LENGTH
             AD    CHRCNT1
             CM    LADA          SPACE >= 1/2 LAST DASH?
             JCGE  CONVERTQ      NO:  CONTINUE MEASURE
             JMP   SPTYPQ        YES: CONVERT
    *
    * CONVERT WHAT WAS STORED IN BUFFERS INTO ASCII CHARACTERS
    *

.....................

    *
    * DASH OR DOT
    *
    MKTYPQ   DAC   **
             LD    LAST          ACC= 2*NEW MARK LENGTH
             AD    LAST
             CM    CHRCNT        IS NEW MARK >= 2* LAST MARK
             JCGE  DOTRQ         LENGTH ? YES: DASH
    DASHRQ   LD    CHRCNT
             ST    LAST          UPDATE LAST MARK LENGTH
             ST    LADA          UPDATE LAST DASH LENGTH
             LDI   X'01'         UPDATE LAST MARK TYPE
             ST    TYPE
             ST*   KPOINT
             INC   KPOINT
             LDI   X'01'         LOAD A '1' INTO DASH REG
             ST    DASH
             LDI   X'00'         LOAD A '0' INTO DOT REG
             ST    DOT
             JMP*  MKTYPQ
    DOTRQ    LD    CHRCNT        ACC. = 2* CURRENT MARK
             AD    CHRCNT
             SBI   X'01'         LENGTH
             CM    LAST          IS MARK < 1/2 LAST MARK?
             JCGE  SAMEQ         NO: DASH OR SAME YES: DOT
    DOTTQ    LD    CHRCNT        UPDATE LAST MARK LENGTH
             ST    LAST          AND LAST MARK TYPE
             LDI   X'00'
             ST    TYPE
             ST*   KPOINT
             INC   KPOINT
             LDI   X'01'         LOAD A '1' INTO DOT
             ST    DOT
             LDI   X'00'
             ST    DASH          LOAD A '0' INTO DASH
             JMP*  MKTYPQ
    SAMEQ    LD    TYPE          WAS LAST MARK A DASH
             CJEQ  X'01',DASHRQ  OR A DOT?
             JMP   DOTTQ

 

[BreakingOhmsLaw]

Does it even make sense to implement this kind of plausibilization?

I think you're saying that you want to build an electronic keyer, and wondering if adding some sort of error detection would be a useful idea.

Yes, this is what I was getting at.
An active error correction is hardly feasible nor useful as you pointed out.
But I could well image that a standalone key that shows you the last character sent (or even the entire message) and indicates where you screwed up with bogus code would be a useful training tool.
This should be well within the capability of a humble 8-bit PIC.

5 WPM is the lower limit in the exam. You can opt to test for 12 WPM to get an extra remark in your diplom that gets you recognition in more countries.
The old greybeards tell me.that its easier to go fast, as slow Morse tempts you into counting dits and dahs. The better way is apparently to learn the "melody" of the character because this uses the part of the brain that handles understanding language which will make it become more or less effortless in the long run.

Anyway, in the exam, anything that actively codes or decodes is naturally not permitted.

[fourfathom]

The better way is apparently to learn the "melody" of the character because this uses the part of the brain that handles understanding language which will make it become more or less effortless in the long run.

Yes.  Look up the "Farnsworth" method for learning Morse code.  This method sends the individual characters at a fairly fast speed, while increasing the inter-character space as needed to slow down the effective Words Per Minute speed.  I learned a very long time ago, in Junior High School "electric shop".  I already knew the rudiments of electricity, so the teacher let me and a few others learn Morse instead.  If we got our ham ticket we would get an "A" grade.  I didn't get the license, but learned to receive over 20 WPM so the teacher gave me the "A" anyway.  We used a "Instructograph" paper tape code practice machine, and it used the normal dit/dah/space timing.  I did get my license a few years later.

For a while, whenever I would learn a new programming language I would write a keyboard-to-morse program, and sometimes a decoding program as well (using PC BIOS ISRs for the timing).  The last one I remember doing was in Turbo Pascal, so I'm definitely a greybeard!

[tkamiya]

Code for a question mark "?" will break the theory you are going with.  It's "..--.."  Dots follow dashes.  And "F"... "..-.".  There are many more examples of starting with dots, followed by dashes, and followed by more dots.

I really don't see any patterns or designs. 

[BreakingOhmsLaw]

Code for a question mark "?" will break the theory you are going with.  It's "..--.."  Dots follow dashes.  And "F"... "..-.".  There are many more examples of starting with dots, followed by dashes, and followed by more dots.

I really don't see any patterns or designs.

Thanks for joining in on the discussion. While that is not wrong, your examples start with two or more dots. I gave an example for codes that start with .  - -

As already established above, the concept was already considered unpractical. While it certainly could be used to detect a non-existent code, there is no good way of correcting the error because multiple "right" choices can follow. Except maybe for aborting the character transmission and automatically send the error code (eight dits) as fourfathom wrote earlier.
So the concept for now would be to just check the sent character against a table of all valid codes and indicate the last character (or indeed an input error) to the user.

Have a nice weekend!