HW(4.0) – Arduino and Microcontrollers: Microcontroller Morse Code System

This section explains how the system captures and interprets button presses to convert user input into Morse code. The approach is based on detecting button press and release events in real time and calculating the duration of the press to determine the input type.

• Sensing the downstroke: Captures the moment the button is pressed and updates the previous state for accurate timing.

• Sensing the upstroke: Captures the moment the button is released to calculate how long the button was held.

• Calculating duration of press: The difference between press and release times determines the type of signal.

• If duration > 0.5 sec: Stores a 2 in the Letter[5] array for a dash (_) and increments the index.

• If duration < 0.5 sec: Stores a 1 for a dot (.), also incrementing the index.

The input system’s design separates brief (dots) from long (dashes) using button press length. The system translates physical motions into digital Morse code by measuring how long the user holds the button. Although the code displayed is for Button 1, Buttons 2 and 3 share the same logic, hence the system is scalable and modular. This guarantees correct input detection throughout several controls and offers a dependable, easy-to-use interface for Morse code production.

The explanation covers the state-based logic for detecting and interpreting button input durations. The system’s main purpose is to uniquely identify each press (downstroke) and release (upstroke) by actively tracking button state changes. This approach measures the button hold duration, maintains accurate event timing, and avoids multiple reads from a single press.

Specifically, the method includes:

• Sensing the downstroke only if state changes: This avoids repeat detection from continuous holds. The press time is recorded and PreviousState is set to HIGH.

• Sensing the upstroke: On release, the time is recorded and PreviousState is set to LOW.

• Calculating duration: Determines how long the button was held.

• Classifying input: If held > 0.5 sec, a dash (‘_’) is stored; if < 0.5 sec, a dot (‘.’) is stored in Letter[5] at the CurrentLoop index.

• Incrementing index: After each input, CurrentLoop is increased to store inputs sequentially.

This system ensures reliable, real-time conversion of button presses into Morse code symbols, enabling accurate message creation.

Automatic Wait Time and Morse Code Translation

This enhancement adds an automatic wait period before converting input into a letter or number. Its purpose is to give users a short window (X seconds) to complete or adjust their input. This makes the system more forgiving, reducing errors from brief pauses or incomplete entries and improving overall input accuracy.

CurrentTime = millis();                                                 
  int button1Pause = CurrentTime - button1Press;                           
  if (button1Pause > 3000 && Letter[0] != 0) {                            

    int CurrentCode;                                                      
    int Let = 0;                                                          
    for (int j=0; j<5;j++) {
      Let = Let * 10 + Letter[j];                                         
    }

    for (int i=0; i<36; i++) {                                            
      CurrentCode = MorseCodes[i];                                         
        if (CurrentCode == Let) {                                                       
          Serial.println("");
          CurrentWord = CurrentWord + AlphaNumericals[i];                 
          Serial.println(CurrentWord);                                    
          Serial.println("");
        }                                    
    }
    for (int i=0; i < 5; i++) {                                           
       Letter[i]=0;
    }

This section of the project converts user input (dots and dashes) into a form fit for Morse code analysis. It occurs after a 3-second gap, and if the Letter[5] array has data. Using a base10 accumulation approach, the system converts the array of digits (e.g., {1, 2, 3, 4, 5}) into a single integer (Let = 12345) . The system requires this because the MorseCodes array stores complete integers. The conversion technique ensures accurate identification of Morse characters from the input sequence.

Letter[] = {1,2,3,4,5}
Let = 0;
Expanded Loop: 
Let = 0 + Let[1] = 0+1 = 1
Let = 1*10 + Let[2] = 10+2 = 12
Let = 12*10 + Let[3] = 120+3 = 123
Let = 123*10 + Let[4] = 1230+4 = 1234
Let = 1234*10 + Let[5] = 12340+5 = 12345

In the Microcontroller Morse Code System, dots are stored as ‘1’ and dashes as ‘2’ in the Letter[5] array to ensure each input is distinguishable from empty array slots, which default to ‘0’.Storing dots as ‘0’ would prevent the system from distinguishing between real inputs and unused slots, breaking the “multiply by 10 then add” conversion method. By using ‘1’ and ‘2’, the design guarantees accurate input representation and reliable Morse code translation.

At this point in the project, the system transforms the user’s input—saved as a Let integer—into its corresponding alphanumeric character. It does so by comparing Let to values in the MorseCodes array. The system appends the matching letter or number (A–Z or 0–9) to the CurrentWord string upon finding a match. As a result, users can watch their message develop in real time as the system converts Morse code inputs into legible text.

With this, I was able to type out letters!

Buttons 2 and 3 – Space and Backspace

Active voice revision:
The system applies the same button-timing logic to buttons 2 and 3 for consistency. Still, there is a noted difference between the law and the physical layout in law; button 2 is the right red button( Backspace), and button 3 is the middle unheroic button( Space). This switch was purposeful to produce a further stoner-friendly and error-resistant layout by distancing secondary functions from the main input button.

 if (button2Duration > 250) {                                        
      LastLetter = CurrentWord.length() - 1;                              
      CurrentWord.remove(LastLetter);                                     
      Serial.println("Backspace");
      Serial.println(CurrentWord);

This final step of the backspace function removes the last character from the CurrentWord string and displays the updated result. It calculates the index of the last character (length minus one), removes itString.remove(index), and then prints the modified string. This gives users instant feedback, confirming that their input correction was successful.

Button 3 triggers two actions based on press duration: a short press adds a space, while a long press displays abbreviated instructions.
A short press (250ms–1s) adds a space to the sentenceCurrentWord, helping users separate words. A longer press (over 1s) displays abbreviated instructions for user guidance. This makes the system more user-friendly by combining help and formatting into one button.

With this, I was able to write out a test with spaces and utilize the backspace function:

Reflections

Difficulties and Challenges

The iterative design and debugging strategy used during code development involved creating multiple code versions and pseudocode to track progress and structure. The Serial Monitor output was frequently modified in earlier versions to test specific functions, such as displaying only _ and . During dot and dash input testing. This method helped isolate and verify individual components, ensuring accurate implementation and overall system reliability.

The issue of button bouncing, where vibrations cause repeated unwanted inputs, is addressed here. Instead of using software fixes, the developer physically adjusted the button’s metal pins to remove gaps between the button and breadboard. This practical solution stopped the bounce and made the system more accurate and reliable.

The main challenge faced by the inventor was understanding how Arduino and C handle data structures, especially compared to MATLAB. C uses zero-grounded indexing, unlike MATLAB’s one-grounded indexing, which added to the confusion. The inventor also acclimatized to how characters, strings, and integers work—for example, recognizing the difference between a single character (“A”), a character array like {“A”, “B”, “C”}, or a string array like {“ABC”, “DEF”}. This adaptation was pivotal for writing accurate law and ensuring the system worked properly.

The Microcontroller Morse Code System has its pros and cons. A key limitation is that design is restricted to the kit’s included parts, though extra components can be added as needed. A major advantage is its flexibility—for example, the developer spontaneously added LEDs as visual feedback, improving usability without prior planning.

Real-World Usage

The foundational concept of this project leverages the timing structures inherent in Morse Code. The basic purpose is to explore and implement a system that interprets timed button presses, much like Morse Code, for practical applications. One stated use is to enhance security by creating a unique Morse Code-based password mechanism for devices such as safes or locks. This project benefits others by offering an alternative and potentially more secure method of access control. The mention of integrating with a “mini-keyboard as a Morse Code input” further illustrates a practical application, showing how existing hardware could be adapted for this specialized input method.

Read more: HW(4.0) – Arduino and Microcontrollers: Microcontroller Morse Code System