SuperMorse

SuperMorse is a modern implementation of the Koch method for learning Morse code, enhanced with features for physical key integration, visual feedback, and simulated HF communication. The application progressively unlocks features as you master Morse code elements, eventually enabling morse communication through a modified Murmur server.

The Koch Method

The Koch Method - A Proven Success: Koch himself, with hand-picked students, got a group to master receiving Morse code at 13 WPM in a mere 13.5 hours - much faster than any other method in the psychological literature. 13.5 hours, that is a average of ≈ 16.75 minutes per sign!

The original Koch method: The Koch method, named after German Ludwig Koch, psychologist at Technische Hochschule, Braunschweig, in 1931, which uses the full target speed from the outset but begins with just two characters. Once strings containing those two characters can be copied with 80% accuracy, an additional character is added, and so on until the full character set is mastered. Your accuracy will of course drop when a new character is introduced, but it will go up again.

SuperMorse uses a modernized variant, because it also will learn you how to use a morse key correctly.

SuperMorse is a modern implementation of the Koch method for learning Morse code, enhanced with features for physical key integration, visual feedback, and simulated HF communication. The application progressively unlocks features as you master Morse code elements, eventually enabling morse communication through a modified Murmur server.

What makes this method so effective:

• Full Speed from the Start: Unlike other methods that start slow and speed up, Koch uses the target speed immediately, training your brain to recognize the sounds at the speed you'll actually use.
• Progressive Character Introduction: By starting with just two characters and adding more only after mastery, the method prevents overwhelm.
• Based on Learned Reflexes: The method builds muscle memory and auditory reflexes, making it effective for both receiving and sending Morse code.

SuperMorse implements this method while adding modern features like regional character support, visual feedback, and integration with physical keys through Arduino.

• Koch Method Training: Progressive learning starting with K and M, adding characters at 80% mastery
• Squeeze Technique Training: Advanced iambic keying with squeeze-priority character progression (default)
• Progress Tracking: Cumulative accuracy across lessons - your progress is never lost
• User Accounts: Secure authentication with email verification
• Visual Feedback: Real-time correct/incorrect character highlighting with technique analysis
• Audio Control: Configurable tone frequency and output device selection
• Session Management: 30-minute lessons with break recommendations
• Regional Support: Multiple language alphabets (Nordic, German, French, etc.)
• Hardware Integration: Arduino key support via Web Serial API with squeeze technique detection

SuperMorse supports a wide range of regional languages in addition to standard International Morse Code:

• Nordic: Norwegian, Swedish, Danish, Finnish, Icelandic, Övdalian (Elfdalian), Northern/Southern Sámi, Faroese.
• German.
• French.
• Cyrillic (Russian).
• Japanese Wabun Code.
• Greek.
• Hebrew.
• Arabic.
• Kurdish.
• Persian (Farsi).
• Devanagari (India).
• Korean (Hangul).

Regional alphabets can be unlocked after mastering the International Morse Code, Prosigns, and Special Characters. Each regional language preserves its authentic character set while maintaining compatibility with the standard Morse code framework.

Targeted Practice is a feature that identifies characters you struggle with:

• Unlocks after mastering International Morse code and Prosigns.
• Analyzes your performance data to identify difficult characters.
• Provides focused practice sessions specifically for challenging characters.
• Tracks improvement on your weak points to help eliminate recurring errors.

Key Training mode allows you to practice sending Morse code using iambic paddle keys connected via Arduino. The system now features an enhanced squeeze technique training method as the default, with the option to use traditional single-paddle methods.

Training Methods:

• Squeeze Technique (Default): Uses proper iambic squeeze keying with 5-character random string training and 80% accuracy progression
• Traditional Method: Legacy single-paddle tapping behavior (can be enabled in Settings)

Squeeze Technique Benefits:

The new default squeeze method teaches optimal dual-paddle techniques for characters that benefit from simultaneous paddle presses:

• Perfect Squeeze Characters: C, K, R, Y - hold both paddles throughout
• Hold + Tap Characters: F, L, P - hold one paddle, tap the other
• Complex Squeeze Characters: Q, X - advanced squeeze patterns

Hardware Requirements:

• Iambic Paddle Key: Dual-paddle Morse key for authentic sending practice
• Arduino Board: Seeeduino XIAO, Arduino Micro, Arduino Nano, or ESP32-C6
• USB Connection: Standard USB cable for Arduino communication
• Wiring: 3-conductor wire (22AWG) for key connections

Iambic Paddle Modes:

• Curtis A Mode: Standard iambic operation with proper timing
• Curtis B Mode: Alternative iambic timing for different preferences
• Ultimatic Mode: Advanced mode for experienced operators

Training Features:

• Progressive Learning: Start with squeeze-priority characters (C, K, R, Y), add characters as you master them
• Speed Control: Adjust sending speed to match your skill level
• Character Groups: Practice with 4 or 5-character groups (configurable)
• Session Tracking: Monitor your practice sessions and progress
• Real-time Feedback: See your sent characters appear immediately with squeeze technique analysis
• Technique Guidance: Get helpful hints and feedback on proper squeeze keying

Settings Configuration:

In the Settings tab, you can configure:

• Use squeeze technique: Toggle between squeeze method (recommended) and traditional single-paddle method
• Use 4-character groups: Switch between standard 5-character and shorter 4-character groups
• Key Mode: Select Iambic A, Iambic B, or Ultimatic mode

Key Training with squeeze technique is essential for developing proper iambic keying skills and muscle memory required for effective Morse code communication using authentic dual-paddle keys.

The squeeze technique is an advanced iambic keying method that allows you to send certain Morse characters more efficiently by using both paddles simultaneously. This technique is now the default training method in Key Training mode.

What is Squeeze Keying?

Squeeze keying involves pressing both paddles at the same time to create alternating dot and dash elements automatically. This technique is based on the behavior of the Curtis 8044A iambic keyer chip, which was used in many professional keyers.

Character Categories by Squeeze Efficiency:

Perfect Squeeze Characters:

• C (-.-.): Hold both paddles throughout the entire character
• K (-.-): Hold both paddles for the entire dash-dit-dash pattern
• R (.-.): Hold both paddles for the dit-dash-dit pattern
• Y (-.--): Hold both paddles for the dash-dit-dash-dash pattern

Hold + Tap Characters:

• F (..-.): Hold dit paddle, tap dash paddle once
• L (.-..): Hold dit paddle, tap dash paddle, then add two more dits
• P (.--.): Hold dit paddle, tap dash paddle twice

Complex Squeeze Characters:

• Q (--.-): Hold dash paddle, tap dit paddle
• X (-..-): Advanced pattern requiring precise timing

Learning Progression:

The system automatically prioritizes squeeze-friendly characters in your learning order:

1. Start with perfect squeeze characters (C, K, R, Y)
2. Progress to hold + tap characters (F, L, P)
3. Learn complex squeeze characters (Q, X)
4. Continue with standard characters

Real-time Feedback:

During training, you'll receive immediate feedback on your technique:

• Positive reinforcement when you use squeeze technique correctly
• Helpful suggestions for characters that benefit from squeeze
• Character-specific hints explaining the optimal technique

Settings Control:

You can control squeeze technique training in the Settings tab:

• Enable/Disable: Toggle between squeeze and traditional methods
• Character Ordering: Automatically adjusts learning progression
• Feedback Level: Receive technique guidance and suggestions

Mastering squeeze technique will significantly improve your Morse code sending speed and efficiency, making you a more proficient operator.

Keyboard Prosign Input in Listening Training

When using the Listening training mode, you can input prosigns (procedural signals) by pressing specific key combinations within a 1.5-second window:

• A+R: Forms the prosign AR (.-.-.) - End of message.
• S+K: Forms the prosign SK (...-.-) - End of contact.
• B+T: Forms the prosign BT (-...-) - Break/new paragraph.
• K+N: Forms the prosign KN (-.--.) - Go ahead, specific station.
• H+H: Forms the prosign HH (........) - Error/correction.

Japanese Code Switching Prosigns (available when Japanese language is unlocked):

• D+O: Forms the prosign DO (-..---) - Switch to Wabun code.
• S+N: Forms the prosign SN (...-.) - Switch back to International Morse code.

To form a prosign, press the first key followed by the second key within 1.5 seconds. The order of keys matters - for example, pressing A and then R forms the valid prosign AR, but pressing R and then A does not form a valid prosign.

SuperMorse provides comprehensive settings to customize your training experience and optimize your learning path.

Training Method Settings:

• Use squeeze technique (recommended): Enables the new default squeeze method with squeeze-priority character progression. When enabled, characters that benefit from squeeze keying (C, K, R, Y, F, L, P, Q, X) are introduced first in your learning order.
• Use 4-character groups: Switch between standard 5-character groups and shorter 4-character groups for training. Standard 5-character groups provide more comprehensive practice, while 4-character groups can be easier for beginners.

Audio Settings:

• Tone Frequency: Adjust the pitch of the Morse code audio (300-1200 Hz)
• Sidetone Frequency: Set the pitch for key press feedback (300-1200 Hz)
• Volume Control: Adjust audio output level
• Audio Device Selection: Choose specific output devices (headphones, speakers, etc.)

Morse Code Settings:

• Morse Speed (WPM): Set the character sending speed (5-40 WPM)
• Farnsworth Timing: Enable faster characters with longer spacing for effective learning
• Farnsworth Ratio: Control the spacing ratio between characters (3.0-10.0)

Arduino/Key Settings:

• Key Mode: Select Iambic A (Curtis A), Iambic B (Curtis B), or Ultimatic mode
• Word Break Threshold: Adjust the pause detection timing between words (300-2000ms)

User Preferences:

• Theme Selection: Choose between light and dark themes
• Maidenhead Locator: Set your grid square location for future features

Settings are automatically saved and synchronized across your devices when you're logged in. The squeeze technique setting is particularly important as it determines your character learning progression and training method.

The app supports these hardware components:

Arduino Boards:

• Seeeduino XIAO – The smallest compatible Arduino board. Can fit into the morse key base if you are handy with tools.
• Seeeduino XIAO ESP32-C6.
• Arduino Micro.
• Arduino Nano.

Morse Key and Cabling:

• Dual-paddle Morse key.
• Suitable USB cable.
• 3-conductor wire, multistrand 22AWG per conductor.

The Arduino firmware supports iambic paddle keys. Here's how to connect your paddle:

Pin Assignments:

• Pin 2 - Paddle dot contact, left paddle.
• Pin 3 - Paddle dash contact, right paddle.

Connection Instructions:

• Connect the dot paddle to pin 2, dash paddle to pin 3, and common to ground.
• All input pins use internal pull-up resistors, so paddles should connect to ground when pressed.

Operating Modes:

The software supports three operating modes:

• Iambic paddle mode A (Curtis A).
• Iambic paddle mode B.
• Ultimatic mode.

If you're experiencing issues with pause detection between Morse elements (dots/dashes) or between characters, try these solutions:

Hardware Solutions:

Clean the Key Contacts:

• Dirty or oxidized contacts can cause erratic behavior.
• Use a contact cleaner spray specifically designed for electronic contacts.
• Apply to both paddle contacts and allow to dry completely before use.
• Regular cleaning maintenance improves reliability significantly.

Adjust the Debounce Value:

• In the Arduino firmware, locate this line: const unsigned long DEBOUNCE_DELAY = 250;
• Increase this value to 500ms: const unsigned long DEBOUNCE_DELAY = 500;
• Higher debounce values help with:
• Dirty or worn contacts.
• "Bouncy" mechanical keys.
• Operators with less consistent timing.

Software Solutions:

Adjust Pause Threshold:

• Use the Pause Threshold slider in settings to find the optimal value for your keying style.
• Start with the default (1 second) and adjust gradually.

These solutions can be used individually or in combination depending on the nature of your input issues.

SuperMorse is an open-source project. You can access the complete source code, contribute to development, or report issues on our GitLab repository:

View Source Code on GitLab

The repository contains:

• Complete web application source code.
• Arduino firmware files.
• Documentation and setup guides.
• Issue tracking and feature requests.

SuperMorse undergoes comprehensive security testing and code quality analysis to ensure your safety and the reliability of the application:

Security Testing:

• Static Application Security Testing (SAST): Detects vulnerabilities like SQL injection, XSS, and command injection
• Secret Detection: Scans for hardcoded credentials, API keys, and sensitive information
• Dependency Scanning: Identifies known vulnerabilities in third-party libraries
• Endpoint Security Analysis: Validates authentication, authorization, and input validation
• Information Disclosure Analysis: Checks for sensitive data leaks in code and documentation

Code Quality Analysis:

• HTML Validation: Ensures proper markup and accessibility standards
• CSS Analysis: Validates stylesheets and identifies potential issues
• JavaScript Analysis: Checks for security patterns and code quality
• PHP Analysis: Validates server-side code against PSR-12 standards
• Code Optimization: Identifies potential improvements and unused code

Worried if this code is considered safe?

View Security Test Results

All tests run automatically on every code change to ensure continuous security and quality monitoring.