Revision 3:7c22a2f849c6, committed 2018-06-02

Comitter:

Ceyhun_Emre

Date:

Sat Jun 02 09:42:25 2018 +0000

Parent:

2:ad0b044d0a10

Commit message:

This code is written for a Morse Encoder-Decoder Device that uses a FRDM-KL25Z board. It can encode the text taken from the keyboard, decode the Morse code taken from the touch slider of the board and transmit the Morse code using LED and buzzer.

Changed in this revision

diff -r ad0b044d0a10 -r 7c22a2f849c6 PS2Keyboard.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/PS2Keyboard.lib	Sat Jun 02 09:42:25 2018 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Bilkent-University-EEE-212-Spring-2018-S/code/PS2Keyboard/#ea6fa42df9ec

diff -r ad0b044d0a10 -r 7c22a2f849c6 SDFileSystem.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/SDFileSystem.lib	Sat Jun 02 09:42:25 2018 +0000
@@ -0,0 +1,1 @@
+https://os.mbed.com/teams/Bilkent-University-EEE-212-Spring-2018-S/code/SDFileSystem/#c7b44c5885a0

diff -r ad0b044d0a10 -r 7c22a2f849c6 TSI.lib
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/TSI.lib	Sat Jun 02 09:42:25 2018 +0000
@@ -0,0 +1,1 @@
+http://os.mbed.com/users/mbed_official/code/TSI/#1a60ef257879

diff -r ad0b044d0a10 -r 7c22a2f849c6 TextLCD.lib
--- a/TextLCD.lib	Sat Dec 04 11:31:07 2010 +0000
+++ b/TextLCD.lib	Sat Jun 02 09:42:25 2018 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/simon/code/TextLCD/#e4cb7ddee0d3
+http://os.mbed.com/users/wim/code/TextLCD/#111ca62e8a59

diff -r ad0b044d0a10 -r 7c22a2f849c6 main.cpp
--- a/main.cpp	Sat Dec 04 11:31:07 2010 +0000
+++ b/main.cpp	Sat Jun 02 09:42:25 2018 +0000
@@ -1,10 +1,1131 @@
-// Hello World! for the TextLCD
-
 #include "mbed.h"
 #include "TextLCD.h"
+#include "PS2ASCII.h"
+#include "TSISensor.h"
+#include "SDFileSystem.h"
+#include <string>       //to define string
+#include <vector>
 
-TextLCD lcd(p15, p16, p17, p18, p19, p20); // rs, e, d4-d7
+// Peripheral IO initializations, the Ticker Object and global variables
+TextLCD lcd(D0, D1, D2, D3, D4, D5, TextLCD::LCD20x4);
+PS2ASCII ps2kb(D6, D7);
+DigitalOut led(LED1);
+DigitalOut buzzer(D8);
+TSISensor touchSlider;
+Ticker callCheckSOS;
+bool stopSOS;
+bool percentageNonZero;
+
+// Screen function declarations. These functions are created to provide modularity to the code.
+// They take references as inputs to modify variables declared in the main function.
+void MenuScreen(int& screenValue, int& cursorIndex);
+void EncodeScreen(int& screenValue, string& textToEncode, string& encodedText, vector<string>& pairToWrite);
+void morseInputScreen(int& screenValue, string& morseInputText, vector<string>& pairToWrite);
+void EmergencySOS(int& screenValue);
+void AfterEncodeOptions(int& screenValue, int& cursorIndex, int& selectedCheckboxes, string& encodedText);
+void afterMorseInputOptions(int& screenValue, int& cursorIndex, int& selectedCheckboxes, string& morseInputText, vector<string>& pairToWrite);
+void writeToSDScreen(int& screenValue, vector<string>& pairToWrite, string& fileName);
+
+// Algorithm function declarations. These functions are the backbone of the project, as they perform encode, decode & transmission tasks.
+string encode (string textToEncode);
+string morseInput();
+string decode( string textToDecode);
+char findChar( string code);
+void checkSOS();
+void transmitLED (string encodedText);
+void transmitBuzzer (string encodedText);
+void transmitLEDAndBuzzer (string encodedText);
+
+// The main function. After performing initial tasks, it enters an infinite loop which only calls screen functions.
+int main() {
+    led = 1; // Turning off the led (active low)
+    
+    // Setting user defined characters (udc) for LCD
+    const char udc_rightCursor[]     = {8, 12, 14, 15, 14, 12, 8, 0};
+    const char udc_emptyCheckBox[]   = {0, 31, 17, 17, 17, 17, 31, 0};
+    const char udc_fullCheckBox[] = {0, 31, 31, 31, 31, 31, 31, 0};
+    
+    lcd.setUDC(0, (char *) udc_rightCursor);
+    lcd.setUDC(1, (char *) udc_emptyCheckBox);
+    lcd.setUDC(2, (char *) udc_fullCheckBox);
+    
+    // Intro Screen
+    lcd.setCursor(TextLCD::CurOff_BlkOff);
+    lcd.printf("     Morse Code\n");
+    lcd.locate(0, 1);
+    lcd.printf(" Encoder - Decoder\n");
+    lcd.locate(0, 2);
+    lcd.printf("     Device by\n");
+    lcd.locate(0, 3);
+    lcd.printf("      CS & CEO\n");
+    wait(3);
+    
+    // Variable declarations which are passed between screens (they work similar to a global variable)
+    int screenValue = 0;
+    int cursorIndex = 0;
+    int selectedCheckboxes = 0;
+    
+    string textToEncode = "";
+    string morseInputText = "";
+    string encodedText = "";
+    string decodedText = "";
+    string fileName = "";
+    vector<string> pairToWrite(2);
+    pairToWrite[0] = "";
+    pairToWrite[1] = "";
+    
+    // The infinite loop with only a simple switch-case block that calls screens according to the screenValue variable.
+    // This variable is modified at the end of any screen function so that main program calls in appropriate screen.
+    while(1) {
+        lcd.cls();
+        
+        switch (screenValue) {
+            case 0 :
+                MenuScreen(screenValue, cursorIndex);
+                break;
+            case 1 :
+                EncodeScreen(screenValue, textToEncode, encodedText, pairToWrite);
+                break;
+            case 2 :
+                morseInputScreen(screenValue, morseInputText, pairToWrite);
+                break;
+            case 3 :
+                EmergencySOS(screenValue);
+                break;
+            case 4 :
+                AfterEncodeOptions(screenValue, cursorIndex, selectedCheckboxes, encodedText);
+                break;
+            case 5 :
+                afterMorseInputOptions(screenValue, cursorIndex, selectedCheckboxes, morseInputText, pairToWrite);
+                break;
+            case 6 :
+                writeToSDScreen(screenValue, pairToWrite, fileName);
+                break;
+            default :
+                MenuScreen(screenValue, cursorIndex);
+        }
+        
+    }
+       
+}
+
+// This function constructs the main menu screen. Here, the user can select one of the four options to perform through a cursor interface.
+// The cursor can be moved with PS/2 keyboard arrow keys and the option can be selected by pressing the Enter key.
+void MenuScreen(int& screenValue, int& cursorIndex) {
+    const int CURSOR_MAX_INDEX = 3;     // The constant showing the max. location of the cursor, starting from index 0.
+    
+    lcd.locate(0, 0);
+    lcd.printf("  Encode Text\n");          // Launchs the encode screen.
+    lcd.locate(0, 1);
+    lcd.printf("  Input Morse Code\n");     // Launchs the Morse input screen
+    lcd.locate(0, 2);
+    lcd.printf("  Emergency SOS!\n");       // Launchs the emergency SOS (distress signal) screen.
+    lcd.locate(0, 3);  
+    lcd.printf("  Write to SD Card\n");     // Launchs the SD Card screen
+
+    // Places the cursor to the appropriate screen. The cursor character is in the 0th custom character RAM location.
+    lcd.locate(0, cursorIndex);
+    lcd.putc(0x00);
+    
+    // Asks for keypress from the keyboard and sets the arrowValue variable to 0. 
+    // Followingly, this variable is given a value of 1 or -1 according to the arrow (or 0 for other keys).   
+    unsigned char pressedChar = ps2kb.getChar();
+    int arrowValue = 0;
+            
+    if (ps2kb.E0flag() || !ps2kb.numlock()) {
+        switch (pressedChar) {
+            case 0x72 :
+                arrowValue = 1;
+                break;
+            case 0x74 :
+                arrowValue = 1;
+                break;
+            case 0x75 :
+                arrowValue = -1;
+                break;
+            case 0x6B:
+                arrowValue = -1;
+                break;
+            default:
+                arrowValue = 0;
+        }
+            
+            cursorIndex += arrowValue; // arrowValue is added to the cursorIndex to move the cursor on the next iteration of the screen.
+            
+            // Algorithm to prevent the overflow of the cursorIndex and keep it in the interval [0, CURSOR_MAX_INDEX]
+            if (cursorIndex == -1)
+                cursorIndex = CURSOR_MAX_INDEX;
+                
+            else if (cursorIndex == (CURSOR_MAX_INDEX + 1))
+                cursorIndex = 0;
+                    
+    }
+    
+    // If Enter is pressed, this block sets the screenValue and clears the cursorIndex for the execution of the chosen screen.
+    if (pressedChar == 0x5A) {
+        switch  (cursorIndex) {
+            case 0 :
+                screenValue = 1;
+                cursorIndex = 0;
+                
+                lcd.cls();
+                lcd.printf("Please enter the\n");
+                lcd.locate(0, 1);
+                lcd.printf("text to be encoded.\n");
+                lcd.locate(0, 2);
+                lcd.printf("\"Enter\": Encode\n");
+                lcd.locate(0, 3);
+                lcd.printf("\"Esc\": Cancel\n");
+                wait(3);
+                
+                lcd.cls();
+                lcd.setCursor(TextLCD::CurOn_BlkOn);
+                
+                break;
+                
+            case 1 :
+                screenValue = 2;
+                cursorIndex = 0;
+                break;
+                
+            case 2 :
+                screenValue = 3;
+                cursorIndex = 0;
+                break;
+            
+            case 3:
+                screenValue = 6;
+                cursorIndex = 0;
+                
+                lcd.cls();
+                lcd.printf("Please enter the\n");
+                lcd.locate(0, 1);
+                lcd.printf("file name.\n");
+                lcd.locate(0, 2);
+                lcd.printf("\"Enter\": Proceed\n");
+                wait(3);
+                
+                lcd.cls();
+                lcd.setCursor(TextLCD::CurOn_BlkOn);
+                
+                break;
+                
+            default :
+                screenValue = 0;
+        }
+    }
+}
+
+// This function launchs the encode screen, where the user is promped to enter a text to encode, through the keyboard.
+void EncodeScreen(int& screenValue, string& textToEncode, string& encodedText, vector<string>& pairToWrite) {
+    lcd.cls();
+    lcd.printf(textToEncode.c_str());
+    unsigned char pressedChar = ps2kb.getChar();
+    
+    // The Esc keypress sends the user back to the menu screen.
+    if (pressedChar == 0x76) {
+        lcd.setCursor(TextLCD::CurOff_BlkOff);
+        textToEncode = "";
+        screenValue = 0;
+    }
+    
+    // The Enter key prompts the device to take the text as the input for the encode algorithm.    
+    else if (pressedChar == 0x5A) {
+        
+        // If nothing is entered, the user is warned to do so.
+        if (textToEncode.compare("") == 0) {
+            lcd.setCursor(TextLCD::CurOff_BlkOff);
+            lcd.printf("Please enter a text first.\n");
+            wait(2);
+            lcd.setCursor(TextLCD::CurOn_BlkOn);
+        }
+        
+        // If the user enters a text, this block calls in the encode function and moves to post-encode screen.
+        else {
+            screenValue = 4;
+            
+            encodedText = encode(textToEncode);
+            pairToWrite[0] = textToEncode;
+            pairToWrite[1] = encodedText;
+            textToEncode = "";
+            lcd.setCursor(TextLCD::CurOff_BlkOff);
+            lcd.cls();
+            lcd.printf("Encode Successful!\n");
+            lcd.locate(0, 1);
+            lcd.printf("Please check display\n");
+            lcd.locate(0, 2);
+            lcd.printf("and transmit options\n");
+            lcd.locate(0, 3);
+            lcd.printf("you want.\n");
+            wait(1);
+            lcd.cls();
+        }
+    }
+    
+    // If Backspace is pressed, a character is erased, unless there is nothing to erase.    
+    else if (pressedChar == 0x66) {
+        if (textToEncode.compare("") != 0)
+            textToEncode = textToEncode.substr(0, textToEncode.length() - 1);
+    }
+    
+    // If something else is pressed, it is appended to the textToEncode screen.
+    else 
+        textToEncode += ps2kb.getASCII(pressedChar);
+          
+ } 
+
+// This function launches the post-encode screen where the user can choose any combination of
+// transmission by LED and/or buzzer and displaying the encoded text. 
+void AfterEncodeOptions(int& screenValue, int& cursorIndex, int& selectedCheckboxes, string& encodedText) {
+    const int CURSOR_MAX_INDEX = 2;
+    
+    lcd.cls();
+    lcd.printf("  Transmit Mode:\n");
+    lcd.locate(2, 1);
+    lcd.printf("  LED\n");
+    lcd.locate(2, 2);
+    lcd.printf("  Buzzer\n");
+    lcd.locate(0, 3);
+    lcd.printf("  Display\n");
+    
+    // Cursor is placed into the appropriate position, which is moved by the arrow keys.   
+    lcd.locate(0, cursorIndex + 1);
+    lcd.putc(0x00);
+    
+    // This block prints the checkboxes next to the options, either empty or full according to user's choice.   
+    lcd.locate(11, 1);
+    if ((selectedCheckboxes & 0x01) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+       
+    lcd.locate(11, 2);
+    if ((selectedCheckboxes & 0x02) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+            
+    lcd.locate(11, 3);
+    if ((selectedCheckboxes & 0x04) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+        
+    unsigned char pressedChar = ps2kb.getChar();
+    int arrowValue = 0;
+    
+    // Same arrowValue algorithm from the main menu.
+    if (ps2kb.E0flag() || !ps2kb.numlock()) {
+        switch (pressedChar) {
+            case 0x72 :
+                arrowValue = 1;
+                break;
+            case 0x74 :
+                arrowValue = 1;
+                break;
+            case 0x75 :
+                arrowValue = -1;
+                break;
+            case 0x6B:
+                arrowValue = -1;
+                break;
+            default:
+                arrowValue = 0;
+        }
+            
+        cursorIndex += arrowValue;
+            
+        if (cursorIndex == -1)
+            cursorIndex = 2;
+                
+        else if (cursorIndex == (CURSOR_MAX_INDEX + 1))
+            cursorIndex = 0;
+                    
+    }
+    
+    // If Space is pressed, the device either selects or deselects the checkbox
+    // depending on the previous state. This is done through the selectedCheckboxes
+    // variable, which stores the states of the checkboxes in its first 3 bits.
+    // The complement operation is done through bitwise AND comparison in if-else blocks
+    // inside a switch-case block.
+    if (pressedChar == 0x29) {
+        switch (cursorIndex) {
+            case 0 :
+                if ((selectedCheckboxes & 0x01) == 0x00)
+                    selectedCheckboxes += 1;
+                else
+                    selectedCheckboxes -= 1;
+                break;
+            case 1 :
+                if ((selectedCheckboxes & 0x02) == 0x00)
+                    selectedCheckboxes += 2;
+                else
+                    selectedCheckboxes -= 2;
+                break;
+            case 2 :
+                if ((selectedCheckboxes & 0x04) == 0x00)
+                    selectedCheckboxes += 4;
+                else
+                    selectedCheckboxes -= 4;
+                break;
+        }
+    }
+    
+    // When Enter is pressed, the options chosen are executed.    
+    else if (pressedChar == 0x5A) {
+        
+        // If no checkbox is selected, the user is warned.
+        if (selectedCheckboxes == 0) {
+            lcd.cls();
+            lcd.printf("Please select at    least 1 checkbox.\n");
+            wait(2);
+        }
+        
+        else {
+            lcd.cls();
+            // If display option is chosen, it is executed first.
+            if (selectedCheckboxes >= 4)
+                lcd.printf(encodedText.c_str());
+            
+            // Transmit algorithms are checked and executed if selected.
+            if ((selectedCheckboxes & 0x03) == 0x01)
+                transmitLED(encodedText);
+            else if ((selectedCheckboxes & 0x03) == 0x02)
+                transmitBuzzer(encodedText);
+            else if ((selectedCheckboxes & 0x03) == 0x03)
+                transmitLEDAndBuzzer(encodedText);
+            else
+                wait(5); // Display duration when no transmit is selected.
+            
+            lcd.cls();
+            screenValue = 0;
+            cursorIndex = 0;
+            selectedCheckboxes = 0;
+            encodedText = "";
+        }
+    }
+}
+
+// This function launchs the encode screen, where the user is promped to enter a text to decode, through the
+// capacitive touch slider.
+void morseInputScreen(int& screenValue , string& morseInputText, vector<string>& pairToWrite) {
+    // The instructions are displayed to the user, since the Morse input procedure is more
+    // sophisticated than the text input.
+    lcd.cls();
+    lcd.printf( "Press for each\n");
+    lcd.locate(0,1);
+    lcd.printf( "time red led is on\n");
+    wait( 3);
+    lcd.cls();
+    
+    lcd.printf( "bottom* of slider: -\n");
+    lcd.locate(0, 1);
+    lcd.printf( "top* of slider: .\n");
+    lcd.locate(0, 2);
+    lcd.printf( ".-.-.: END\n"); // End of message sequence to end the input.
+    lcd.locate(0, 3);
+    lcd.printf( "*when USB is on left");
+    wait( 3);
+    lcd.cls();
+    
+    lcd.printf( "Missing 1 period:\n");
+    lcd.locate(0, 1);
+    lcd.printf( "space between char.s\n");
+    lcd.locate(0, 2);
+    lcd.printf( "Missing 2 periods:\n");
+    lcd.locate(0, 3);
+    lcd.printf( "space between words\n");
+    wait( 3);
+    lcd.cls();
+    
+    // Morse input algorithm is called.
+    morseInputText = morseInput();
+    pairToWrite[0] = morseInputText;
+    screenValue = 5;
+}
 
-int main() {
-    lcd.printf("Hello World!\n");
+// This function launches the post-morse input screen where the user can choose any combination of
+// transmission by LED and/or buzzer and decoding & displaying the decodec text. 
+void afterMorseInputOptions(int& screenValue, int& cursorIndex, int& selectedCheckboxes, string& morseInputText, vector<string>& pairToWrite) {
+    const int CURSOR_MAX_INDEX = 2;
+    
+    lcd.cls();
+    lcd.printf("  Transmit Mode:\n");
+    lcd.locate(2, 1);
+    lcd.printf("  LED\n");
+    lcd.locate(2, 2);
+    lcd.printf("  Buzzer\n");
+    lcd.locate(0, 3);
+    lcd.printf("  Decode & Display\n");
+    
+    // Cursor is placed into the appropriate position, which is moved by the arrow keys.   
+    lcd.locate(0, cursorIndex + 1);
+    lcd.putc(0x00);
+    
+    // This block prints the checkboxes next to the options, either empty or full according to user's choice.    
+    lcd.locate(11, 1);
+    if ((selectedCheckboxes & 0x01) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+       
+    lcd.locate(11, 2);
+    if ((selectedCheckboxes & 0x02) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+            
+    lcd.locate(20, 3);
+    if ((selectedCheckboxes & 0x04) == 0x00)
+        lcd.putc(0x01);
+    else
+        lcd.putc(0x02);
+        
+    unsigned char pressedChar = ps2kb.getChar();
+    int arrowValue = 0;
+    
+    // Same arrowValue algorithm from the main menu.
+    if (ps2kb.E0flag() || !ps2kb.numlock()) {
+        switch (pressedChar) {
+            case 0x72 :
+                arrowValue = 1;
+                break;
+            case 0x74 :
+                arrowValue = 1;
+                break;
+            case 0x75 :
+                arrowValue = -1;
+                break;
+            case 0x6B:
+                arrowValue = -1;
+                break;
+            default:
+                arrowValue = 0;
+        }
+            
+        cursorIndex += arrowValue;
+            
+        if (cursorIndex == -1)
+            cursorIndex = 2;
+                
+        else if (cursorIndex == (CURSOR_MAX_INDEX + 1))
+            cursorIndex = 0;
+                    
+    }
+    
+    // Same checkbox algorithm from the post-encode screen.
+    if (pressedChar == 0x29) {
+        switch (cursorIndex) {
+            case 0 :
+                if ((selectedCheckboxes & 0x01) == 0x00)
+                    selectedCheckboxes += 1;
+                else
+                    selectedCheckboxes -= 1;
+                break;
+            case 1 :
+                if ((selectedCheckboxes & 0x02) == 0x00)
+                    selectedCheckboxes += 2;
+                else
+                    selectedCheckboxes -= 2;
+                break;
+            case 2 :
+                if ((selectedCheckboxes & 0x04) == 0x00)
+                    selectedCheckboxes += 4;
+                else
+                    selectedCheckboxes -= 4;
+                break;
+        }
+    }
+    
+    // When Enter is pressed, the options chosen are executed.    
+    else if (pressedChar == 0x5A) {
+        
+        // If no checkbox is selected, the user is warned.
+        if (selectedCheckboxes == 0) {
+            lcd.cls();
+            lcd.printf("Please select at    least 1 checkbox.\n");
+            wait(1);
+        }
+        
+        else {
+            // If decode & display option is chosen, it is executed first.
+            lcd.cls();
+            if (selectedCheckboxes >= 4) {
+                string decodedText = decode( morseInputText);
+                pairToWrite[1] = decodedText;
+                lcd.printf(decodedText.c_str());
+            }
+            else
+               pairToWrite[1] = ""; // Empty string is written to the SD card variable, if decode is not selected
+            
+            // Transmit algorithms are checked and executed if selected.
+            if ((selectedCheckboxes & 0x03) == 0x01)
+                transmitLED(morseInputText);
+            else if ((selectedCheckboxes & 0x03) == 0x02)
+                transmitBuzzer(morseInputText);
+            else if ((selectedCheckboxes & 0x03) == 0x03)
+                transmitLEDAndBuzzer(morseInputText);
+            else
+                wait(5); // Display duration when no transmit is selected.
+            
+            lcd.cls();
+            screenValue = 0;
+            cursorIndex = 0;
+            selectedCheckboxes = 0;
+            morseInputText = "";
+        }
+    }
+}
+
+// This function is called when emergency SOS screen is chosen. This screen simply transmits
+// an SOS signal through LED and buzzer in an infinite loop until being interrupted by the user.
+void EmergencySOS(int& screenValue){
+    const string SOS_MORSE_CODE = "...---..."; // SOS Morse code string
+    lcd.cls();
+    lcd.printf( "Press touch slider\n");
+    lcd.locate(0, 1);
+    lcd.printf( "to cancel SOS signal\n");
+    
+    percentageNonZero = false;
+    callCheckSOS.attach( &checkSOS, 0.05); // Attachs the callCheckSOS Ticker to checkSOS function
+    do {
+        transmitLEDAndBuzzer( SOS_MORSE_CODE);
+        wait(0.75);
+    } while ( !stopSOS);
+    
+    callCheckSOS.detach();
+    lcd.cls();
+    screenValue = 0;
+}
+
+// This function is called whenever the interrupt timer overflows in 50 ms. It checks the capacitive touchslider
+// output. If it is different than 0 (in other words, it it is touched at least once), the stopSOS boolean is
+// set true and the do while loop above is exited, which terminates the distress signal.
+void checkSOS() {
+    if ( !percentageNonZero && touchSlider.readPercentage() == 0) {
+        stopSOS = false;
+    }
+    else {
+        stopSOS = true;
+        percentageNonZero = true;
+    }
+}   
+
+// This function calls in the write-to-SD-card screen where the user can write the last
+// text-Morse code pair (either encoded or decoded into the microSD card in the adapter connected to the device.
+void writeToSDScreen(int& screenValue, vector<string>& pairToWrite, string& fileName) {
+    SDFileSystem sdCard(D11, D12, D13, D10, "SD CARD");
+    lcd.cls();
+    lcd.printf(fileName.c_str());
+    unsigned char pressedChar = ps2kb.getChar();
+    
+    // The user is promped to enter the file name.    
+    if (pressedChar == 0x5A) {
+        
+        // The user is warned if no text is entered.
+        if (fileName.compare("") == 0) {
+            lcd.setCursor(TextLCD::CurOff_BlkOff);
+            lcd.printf("Please enter a text first.\n");
+            wait(2);
+            lcd.setCursor(TextLCD::CurOn_BlkOn);
+        }
+        
+        // Functions of the SD card library are called to write the text and morse code
+        // texts into the card.
+        else {
+            lcd.setCursor(TextLCD::CurOff_BlkOff);
+            lcd.cls();
+            screenValue = 0;
+            
+            string fileDirectory = "/SD CARD/morse_enc_dec_dev/"; // Pre-defined directory.
+            mkdir("/SD CARD/morse_enc_dec_dev", 0777);
+            fileDirectory += fileName; // fileName is added to the fileDirectory.
+            fileDirectory += ".txt";
+            FILE *fp = fopen(fileDirectory.c_str(), "w");
+            if (fp == NULL) {
+                error("Could not open file for write\n");
+            }
+            string textToWrite = pairToWrite[0] + "   " + pairToWrite[1];
+            fprintf(fp, textToWrite.c_str());
+            fclose(fp);
+           
+            lcd.cls();
+            lcd.printf("Write to SD is      successful!"); // Success message
+            wait(2);
+            lcd.cls();
+            
+            screenValue = 0;   
+            fileName = "";
+            lcd.setCursor(TextLCD::CurOff_BlkOff);
+            
+        }
+    }
+        
+    else if (pressedChar == 0x66) {
+        if (fileName.compare("") != 0)
+            fileName = fileName.substr(0, fileName.length() - 1);
+    }
+    
+    else 
+        fileName += ps2kb.getASCII(pressedChar);
+          
 }
+
+// This function takes text input as string and uses the binary Morse tree, coded
+// in if-else blocks, to convert it to Morse code. It outputs the result as a string.
+string encode( string textToEncode) {
+    string encodedText = "";
+    char checkedLetter;
+    
+    for ( short int counter = 0; counter < textToEncode.length(); counter++) {
+        checkedLetter = textToEncode.at( counter);
+        if ( checkedLetter == ' ') {
+            encodedText += '/'; // '/' for the space between words ( 4 unit 
+            // times for this char => 7 unit times for space between words)
+        }
+        else if ( checkedLetter == 'e' || checkedLetter == 'i' || checkedLetter == 'a'
+               || checkedLetter == 's' || checkedLetter == 'u' || checkedLetter == 'r' 
+               || checkedLetter == 'w' || checkedLetter == 'h' || checkedLetter == 'v' 
+               || checkedLetter == 'f' || checkedLetter == 'l' || checkedLetter == 'p' 
+               || checkedLetter == 'j' || checkedLetter == '5' || checkedLetter == '4' 
+               || checkedLetter == '3' || checkedLetter == '2' || checkedLetter == '1' ) {
+            encodedText += '.';
+            if ( checkedLetter == 'i' || checkedLetter == 's' || checkedLetter == 'u'
+              || checkedLetter == 'h' || checkedLetter == 'v' || checkedLetter == 'f'
+              || checkedLetter == '5' || checkedLetter == '4' || checkedLetter == '3' 
+              || checkedLetter == '2') {
+                encodedText += '.';
+                if ( checkedLetter == 's' || checkedLetter == 'h' || checkedLetter == 'v'
+                  || checkedLetter == '5' || checkedLetter == '4' || checkedLetter == '3') {
+                    encodedText += '.';
+                    if ( checkedLetter == 'h' || checkedLetter == '5' 
+                      || checkedLetter == '4') {
+                        encodedText += '.';
+                        if ( checkedLetter == '5') {
+                            encodedText += '.';
+                        }
+                        else if ( checkedLetter != 'h') { // checkedLetter = '4'
+                            encodedText += '-';
+                        }
+                    }
+                    else if ( checkedLetter != 's') {
+                        encodedText += '-';
+                        if ( checkedLetter == '3') {
+                            encodedText += '-';
+                        }
+                    }
+                }  
+                else if ( checkedLetter != 'i'){
+                    encodedText += '-';
+                    if ( checkedLetter == 'f') {
+                        encodedText += '.';
+                    }
+                    else if ( checkedLetter != 'u'){ // checkedLetter = '2'
+                        encodedText += "--";  
+                    }
+                }
+            }
+            else if ( checkedLetter != 'e') {
+                encodedText += '-';
+                if ( checkedLetter == 'r' || checkedLetter == 'l') {
+                    encodedText += '.';
+                    if ( checkedLetter == 'l') {
+                        encodedText += '.';
+                    }
+                }
+                else if ( checkedLetter != 'a'){
+                    encodedText += '-';
+                    if ( checkedLetter == 'p') {
+                        encodedText += '.';
+                    }
+                    else if ( checkedLetter != 'w'){
+                        encodedText += '-';
+                        if ( checkedLetter == '1') {
+                            encodedText += '-';
+                        }
+                    }
+                }
+            }
+        }
+        else { 
+            encodedText += '-';
+            if ( checkedLetter == 'n' || checkedLetter == 'd' || checkedLetter == 'k'
+              || checkedLetter == 'b' || checkedLetter == 'x' || checkedLetter == 'c'
+              || checkedLetter == 'y' || checkedLetter == '6') {
+                encodedText += '.'; 
+                if ( checkedLetter == 'd' || checkedLetter == 'b' 
+                  || checkedLetter == 'x' || checkedLetter == '6') {
+                    encodedText += '.';
+                    if ( checkedLetter == 'b' || checkedLetter == '6') {
+                        encodedText += '.';
+                        if ( checkedLetter == '6') {
+                            encodedText += '.';
+                        }
+                    }
+                    else if ( checkedLetter != 'd') { //checkedLetter = 'x'
+                        encodedText += '-';
+                    }
+                }
+                else if ( checkedLetter != 'n'){
+                    encodedText += '-';
+                    if ( checkedLetter == 'c') {
+                        encodedText += '.';
+                    }
+                    else if ( checkedLetter != 'k') { // checkedLetter = 'y'
+                        encodedText += '-';
+                    }
+                }
+            }
+            else if ( checkedLetter != 't'){
+                encodedText += '-';
+                if ( checkedLetter == 'g' || checkedLetter == 'z' || checkedLetter == 'q'
+                  || checkedLetter == '7') {
+                    encodedText += '.';
+                    if ( checkedLetter == 'z' || checkedLetter == '7') {
+                        encodedText += '.';
+                        if ( checkedLetter == '7') {
+                            encodedText += '.';
+                        }
+                    }
+                    else if ( checkedLetter != 'g') { // checkedLetter = 'q'
+                        encodedText += '-';
+                    }
+                }
+                else if ( checkedLetter != 'm') {
+                    encodedText += '-';
+                    if ( checkedLetter == '8') {
+                        encodedText += "..";
+                    }
+                    else if ( checkedLetter != 'o'){
+                        encodedText += '-';
+                        if ( checkedLetter == '9') {
+                            encodedText += '.';
+                        }
+                        else { //checkedLetter = 0 
+                            encodedText += '-';
+                        }
+                    }
+                }
+            }
+        }
+        encodedText += ' '; // ' ' for the space between letters ( 3 unit 
+        //times for this char)
+    }
+    return encodedText;
+}
+
+// This function is called to take Morse code input from the capacitive touchslider.
+string morseInput() {
+    //for taking input
+    //constants
+    const double unitTimeForDecoding = 1; // 250 miliseconds
+    
+    //variables
+    string textToDecode;
+    short int numberOfSpaces; // to check if a word has ended
+    float currentValue;
+    float pressedValue;
+    string addLetter;
+    bool change;
+    bool takeMorseInput;
+    
+    //initialization
+    textToDecode = "";
+    numberOfSpaces = 0;
+    change = true;
+    takeMorseInput = true;
+    
+    wait( unitTimeForDecoding);
+    while( takeMorseInput) {
+        led = 0; //indicating that input can be taken now
+        for ( short int counter = 0; counter < 200; counter++) {
+            wait( unitTimeForDecoding / 200);
+            if ( ( currentValue = touchSlider.readPercentage()) > 0 && change) {
+                change = false;
+                pressedValue = currentValue;
+            }
+            
+            if ( touchSlider.readPercentage() == 0 && change) {
+                pressedValue = 0;
+            }
+        }
+        change = true;
+        led = 1; //indicating pause
+        
+        if ( pressedValue <= 0) {
+            addLetter = " ";
+            numberOfSpaces++;
+            if ( numberOfSpaces >= 2) { // seperate words
+                addLetter = "/ ";
+            } 
+        }
+        else if ( 0.5 < pressedValue && pressedValue <= 1) {
+            addLetter = "-";
+            numberOfSpaces = 0;
+        }
+        else {
+            addLetter = ".";
+            numberOfSpaces = 0;
+        }
+        textToDecode += addLetter;
+        wait( unitTimeForDecoding);
+        
+        if ( textToDecode.length() > 6) {
+            if ( ( textToDecode.substr( textToDecode.length() - 6, 6)).compare(" .-.-.") == 0) {
+                takeMorseInput = false;
+            }
+        }
+    }
+    
+    if ( textToDecode.at( 0) == ' ') {
+        textToDecode = textToDecode.substr( (int) textToDecode.find_first_not_of( " /"), 
+                                            textToDecode.length() - 6 - (int) textToDecode.find_first_not_of( " /"));
+    }
+    else {
+        textToDecode = textToDecode.substr( 0, textToDecode.length() - 6);
+    }
+    return textToDecode;
+}
+
+// This function decodes the Morse code taken as a string and returns the text result as
+// a string. It uses again the binary Morse code tree, coded inside the findChar function.
+string decode( string textToDecode) {
+    //for decoding
+    //variables
+    string decodedText;
+    string codeForEachLetter;
+    
+    //initialization
+    decodedText = "";
+    codeForEachLetter = "";
+    
+    // decodes all characters other than the last one
+    while ( textToDecode.find( " ") != std::string::npos) {
+        codeForEachLetter = textToDecode.substr(0, textToDecode.find( " ")); 
+        decodedText += findChar( codeForEachLetter);
+        textToDecode = textToDecode.substr( textToDecode.find( " ") + 1, 
+                                            textToDecode.length() 
+                                            - ( textToDecode.find( " ") + 1));
+    }
+    //decodes the last character
+    decodedText += findChar( textToDecode);
+    
+    return decodedText;
+    
+}
+
+//This function performs the conversion to character while decoding. It is based
+//on binary Morse code tree.
+char findChar( string code) {
+    if ( code.at( 0) == '.') {
+        if ( code.length() != 1) {
+            if ( code.at( 1) == '.') {
+                if ( code.length() != 2) {
+                    if ( code.at( 2) == '.') {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                if ( code.length() != 4) {
+                                    if ( code.at( 4) == '.') {
+                                        return '5';
+                                    }
+                                    return '4';
+                                }
+                                return 'H';
+                            }
+                            else {
+                                if ( code.length() != 4) {
+                                    return '3';
+                                }
+                                return 'V';
+                            }
+                        }
+                        return 'S';
+                    }
+                    else {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                return 'F';
+                            }
+                            return '2';
+                        }
+                        return 'U';
+                    }
+                }
+                return 'I';
+            }
+            else {
+                if ( code.length() != 2) {
+                    if ( code.at( 2) == '.') {
+                        if ( code.length() != 3) {
+                            return 'L';
+                        }
+                        return 'R';
+                    }
+                    else {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                return 'P';
+                            }
+                            if ( code.length() != 4) {
+                                return '1';
+                            }
+                            return 'J';
+                        }
+                        return 'W';
+                    }
+                }
+                return 'A';
+            }
+        }
+        return 'E';
+    }
+    else if ( code.at( 0) == '-') {
+        if ( code.length() != 1) {
+            if ( code.at( 1) == '.') {
+                if ( code.length() != 2) {
+                    if ( code.at( 2) == '.') {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                if ( code.length() != 4) {
+                                    return '6';
+                                }
+                                return 'B';
+                            }
+                            return 'X';
+                        }
+                        return 'D';
+                    }
+                    else {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                return 'C';
+                            }
+                            return 'Y';
+                        }
+                        return 'K';
+                    }
+                }
+                return 'N';
+            }
+            else {
+                if ( code.length() != 2) {
+                    if ( code.at( 2) == '.') {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                if ( code.length() != 4) {
+                                    return '7';
+                                }
+                                return 'Z';
+                            }
+                            return 'Q';
+                        }
+                        return 'G';
+                    }
+                    else {
+                        if ( code.length() != 3) {
+                            if ( code.at( 3) == '.') {
+                                return '8';
+                            }
+                            if ( code.at( 4) == '.') {
+                                return '9';
+                            }
+                            return '0';
+                        }
+                        return 'O';
+                    }
+                }
+                return 'M';
+            }
+        }
+        return 'T';
+    }
+    return ' '; // codeForEachLetter.at( 0) = '/'
+}
+
+// This function transmit the inputted Morse code through LED and buzzer simultaneously.
+void transmitLEDAndBuzzer (string encodedText) {
+    const double unitTime = 0.25; // 250 miliseconds
+    
+    // code to send encodedText to LED and buzzer appropriately 
+    for ( short int counter = 0; counter < encodedText.length(); counter++) {
+        char checkedChar = encodedText.at( counter);
+        if ( checkedChar == '.') {
+            led = 0;
+            buzzer = 1;
+            wait( unitTime);
+            led = 1;
+            buzzer = 0;
+            wait( unitTime);
+        }
+        else if ( checkedChar == '-') {
+            led = 0;
+            buzzer = 1;
+            wait( unitTime * 3);
+            led = 1;
+            buzzer = 0;
+            wait( unitTime);
+        }
+        else if ( checkedChar == ' ') {
+            wait( unitTime * 3);
+        }
+        else { // checkedChar = '/'
+            wait( unitTime);
+        }
+    }
+}
+
+// This function transmit the inputted Morse code through only LED.
+void transmitLED (string encodedText) {
+    const double unitTime = 0.25; // 250 miliseconds
+    
+    // code to send encodedText to LED appropriately 
+    for ( short int counter = 0; counter < encodedText.length(); counter++) {
+        char checkedChar = encodedText.at( counter);
+        if ( checkedChar == '.') {
+            led = 0;
+            wait( unitTime);
+            led = 1;
+            wait( unitTime);
+        }
+        else if ( checkedChar == '-') {
+            led = 0;
+            wait( unitTime * 3);
+            led = 1;
+            wait( unitTime);
+        }
+        else if ( checkedChar == ' ') {
+            wait( unitTime * 3);
+        }
+        else { // checkedChar = '/'
+            wait( unitTime);
+        }
+    }
+}
+
+// This function transmit the inputted Morse code through only buzzer.
+void transmitBuzzer (string encodedText) {
+    const double unitTime = 0.25; // 250 miliseconds
+    
+    // code to send encodedText to buzzer appropriately 
+    for ( short int counter = 0; counter < encodedText.length(); counter++) {
+        char checkedChar = encodedText.at( counter);
+        if ( checkedChar == '.') {
+            buzzer = 1;
+            wait( unitTime);
+            buzzer = 0;
+            wait( unitTime);
+        }
+        else if ( checkedChar == '-') {
+            buzzer = 1;
+            wait( unitTime * 3);
+            buzzer = 0;
+            wait( unitTime);
+        }
+        else if ( checkedChar == ' ') {
+            wait( unitTime * 3);
+        }
+        else { // checkedChar = '/'
+            wait( unitTime);
+        }
+    }
+}   
\ No newline at end of file

diff -r ad0b044d0a10 -r 7c22a2f849c6 mbed.bld
--- a/mbed.bld	Sat Dec 04 11:31:07 2010 +0000
+++ b/mbed.bld	Sat Jun 02 09:42:25 2018 +0000
@@ -1,1 +1,1 @@
-http://mbed.org/users/mbed_official/code/mbed/builds/e2ac27c8e93e
+http://mbed.org/users/mbed_official/code/mbed/builds/5aab5a7997ee
\ No newline at end of file