This is one of my first projects for the Arduino, I wanted to go through the process of creating my own class and thought this might be a fun idea.
Morse code, invented in the 1830s by Samuel Morse and Alfred Vail, revolutionized long-distance communication. It utilizes sequences of dots and dashes to represent letters, numbers, and punctuation. Each character is assigned a unique combination of short and long signals, allowing for transmission via telegraphy and later, radio. Morse code's simplicity and versatility made it indispensable in maritime, military, and aviation communication for decades.
Simple Encoding: Its encoding system, based on combinations of dots and dashes, is straightforward to understand and implement.
Versatility: Morse code can be transmitted through various mediums, including telegraph wires, radio waves, and light signals, making it adaptable to different communication technologies and environments.
Resilience: Its simplicity and redundancy make Morse code resilient to interference and noise, ensuring reliable communication even under adverse conditions.
International Standard: Morse code became an international standard, facilitating communication across language barriers and enabling interoperability between different telecommunication systems worldwide.
Efficiency: Morse code allows for relatively fast transmission speeds once mastered, enabling rapid communication over long distances without the need for complex equipment or infrastructure.
Overall, Morse code's effectiveness stems from its simplicity, versatility, resilience, and widespread adoption as a global communication standard.
In order to use the class, it's very simple. Create a reference to the MorseCode class, then call begin.
- If you don't want to use the LED or Speaker, just set the value -1
- Adjusts the time for a single morse code 'dit'. All of the other timings are relative to this time.
- Set's the tone produced by the speaker.
- Starts the transmition of the char array as morse code.
Note: This class is blocking. The code will not proceed until the message has been sent.
1 : #include "MorseCode.h"
2 :
3 : MorseCode morse = MorseCode();
4 : const int LED_PIN = 5;
5 : const int SPEAKER_PIN = 10;
6 :
7 : void setup() {
8 :
9 : pinMode(LED_PIN,OUTPUT);
10 : pinMode(SPEAKER_PIN,OUTPUT);
11 :
12 : morse.begin(LED_PIN, SPEAKER_PIN); // Set pin to -1 if you don't want the LED or SPEAKER
13 : morse.setSpeed(60); // Set the speed of the 'dit'. All of the other Morse Code timing is calculated from this
14 : morse.setTone(440); // If you are using the speaker/buzzer, this will adjust the tone produced
15 :
16 : char message[] = {"SOS"};
17 : morse.send(message); // Send the message
18 : }
19 :
20 : void loop() {
21 : }
22 :
23 :
1 : #ifndef _MORSE_CODE_H
2 : #define _MORSE_CODE_H
3 :
4 : #include
5 :
6 : class MorseCode {
7 :
8 : public:
9 :
10 : MorseCode(void);
11 :
12 : bool begin (int led, int speaker);
13 :
14 : void send(char message[]);
15 :
16 : void setSpeed (int speed);
17 :
18 : void setTone (int tone);
19 :
20 : private:
21 : void processNumbers (char number);
22 : void processPunctuation (char punctuation);
23 : void processLetters (char letter);
24 : void sendMorseChar(boolean morseValue[], int size);
25 : void dit(void);
26 : void da(void);
27 : void calculateTiming(void);
28 :
29 : const int NOTE_A4 = 440;
30 : const int NOTE_B4 = 494;
31 : const int NOTE_C5 = 523;
32 : const int NOTE_D5 = 587;
33 : const int NOTE_E5 = 659;
34 : const int NOTE_F5 = 698;
35 : const int NOTE_G5 = 784;
36 :
37 : //Morse code definitions
38 : const boolean _morse_A[2] = {0,1};
39 : const boolean _morse_B[4] = {1,0,0,0};
40 : const boolean _morse_C[4] = {1,0,1,0};
41 : const boolean _morse_D[3] = {1,0,0};
42 : const boolean _morse_E[1] = {0};
43 : const boolean _morse_F[4] = {0,0,1,0};
44 : const boolean _morse_G[3] = {1,1,0};
45 : const boolean _morse_H[4] = {0,0,0,0};
46 : const boolean _morse_I[2] = {0,0};
47 : const boolean _morse_J[4] = {0,1,1,1};
48 : const boolean _morse_K[3] = {1,0,1};
49 : const boolean _morse_L[4] = {0,1,0,0};
50 : const boolean _morse_M[2] = {1,1};
51 : const boolean _morse_N[2] = {1,0};
52 : const boolean _morse_O[3] = {1,1,1};
53 : const boolean _morse_P[4] = {0,1,1,0};
54 : const boolean _morse_Q[4] = {1,1,0,1};
55 : const boolean _morse_R[3] = {0,1,0};
56 : const boolean _morse_S[3] = {0,0,0};
57 : const boolean _morse_T[1] = {1};
58 : const boolean _morse_U[3] = {0,0,1};
59 : const boolean _morse_V[4] = {0,0,0,1};
60 : const boolean _morse_W[3] = {0,1,1};
61 : const boolean _morse_X[4] = {1,0,0,1};
62 : const boolean _morse_Y[4] = {1,0,1,1};
63 : const boolean _morse_Z[4] = {1,1,0,0};
64 :
65 : const boolean _morse_1[5] = {0,1,1,1,1};
66 : const boolean _morse_2[5] = {0,0,1,1,1};
67 : const boolean _morse_3[5] = {0,0,0,1,1};
68 : const boolean _morse_4[5] = {0,0,0,0,1};
69 : const boolean _morse_5[5] = {0,0,0,0,0};
70 : const boolean _morse_6[5] = {1,0,0,0,0};
71 : const boolean _morse_7[5] = {1,1,0,0,0};
72 : const boolean _morse_8[5] = {1,1,1,0,0};
73 : const boolean _morse_9[5] = {1,1,1,1,0};
74 : const boolean _morse_0[5] = {1,1,1,1,1};
75 :
76 : const boolean _morse_DOT[6] = {0,1,0,1,0,1};
77 : const boolean _morse_COMMA[6] = {1,1,0,0,1,1};
78 : const boolean _morse_QUESTION[6] = {0,0,1,1,0,0};
79 :
80 : int _speakerPin = 0;
81 : int _ledPin = 0;
82 : int _unitTime = 60;
83 :
84 : int _tone = NOTE_E5;
85 :
86 : int _dit = 0;
87 : int _da = 0;
88 : int _letterBreak = 0;
89 : int _wordBreak = 0;
90 :
91 : };
92 :
93 : #endif
1 : #include "morsecode.h"
2 :
3 : MorseCode::MorseCode(){
4 : //Initialize timing
5 : calculateTiming();
6 : }
7 :
8 : void MorseCode::setSpeed(int speed){
9 : _unitTime = speed;
10 : calculateTiming();
11 : }
12 :
13 : void MorseCode::setTone(int tone){
14 : _tone = tone
15 : }
16 :
17 : bool MorseCode::begin(int led, int speaker){
18 : _ledPin = led;
19 : _speakerPin = speaker;
20 :
21 : return true;
22 : }
23 :
24 : void MorseCode::processNumbers (char number)
25 : {
26 : switch (number)
27 : {
28 : case '0':
29 : sendMorseChar(_morse_0, sizeof(_morse_0));
30 : break
31 :
32 : case '1':
33 : sendMorseChar(_morse_1, sizeof(_morse_1));
34 : break
35 :
36 : case '2':
37 : sendMorseChar(_morse_2, sizeof(_morse_2));
38 : break
39 :
40 : case '3':
41 : sendMorseChar(_morse_3, sizeof(_morse_3));
42 : break
43 :
44 : case '4':
45 : sendMorseChar(_morse_4, sizeof(_morse_4));
46 : break
47 :
48 : case '5':
49 : sendMorseChar(_morse_5, sizeof(_morse_5));
50 : break
51 :
52 : case '6':
53 : sendMorseChar(_morse_6, sizeof(_morse_6));
54 : break
55 :
56 : case '7':
57 : sendMorseChar(_morse_7, sizeof(_morse_7));
58 : break
59 :
60 : case '8':
61 : sendMorseChar(_morse_8, sizeof(_morse_8));
62 : break
63 :
64 : case '9':
65 : sendMorseChar(_morse_9, sizeof(_morse_9));
66 : break
67 : }
68 : }
69 :
70 : void MorseCode::processPunctuation (char punctuation)
71 : {
72 : switch (punctuation)
73 : {
74 : case '.':
75 : sendMorseChar(_morse_DOT, sizeof(_morse_DOT));
76 : break
77 :
78 : case ',':
79 : sendMorseChar(_morse_COMMA, sizeof(_morse_COMMA));
80 : break
81 :
82 : case '?':
83 : sendMorseChar(_morse_QUESTION, sizeof(_morse_QUESTION));
84 : break
85 : }
86 :
87 : }
88 :
89 : void MorseCode::processLetters (char letter)
90 : {
91 : switch (letter)
92 : {
93 : case 'A':
94 : sendMorseChar(_morse_A, sizeof(_morse_A));
95 : break
96 :
97 : case 'B':
98 : sendMorseChar(_morse_B, sizeof(_morse_B));
99 : break
100 :
101 : case 'C':
102 : sendMorseChar(_morse_C, sizeof(_morse_C));
103 : break
104 :
105 : case 'D':
106 : sendMorseChar(_morse_D, sizeof(_morse_D));
107 : break
108 :
109 : case 'E':
110 : sendMorseChar(_morse_E, sizeof(_morse_E));
111 : break
112 :
113 : case 'F':
114 : sendMorseChar(_morse_F, sizeof(_morse_F));
115 : break
116 :
117 : case 'G':
118 : sendMorseChar(_morse_G, sizeof(_morse_G));
119 : break
120 :
121 : case 'H':
122 : sendMorseChar(_morse_H, sizeof(_morse_H));
123 : break
124 :
125 : case 'I':
126 : sendMorseChar(_morse_I, sizeof(_morse_I));
127 : break
128 :
129 : case 'J':
130 : sendMorseChar(_morse_J, sizeof(_morse_J));
131 : break
132 :
133 : case 'K':
134 : sendMorseChar(_morse_K, sizeof(_morse_K));
135 : break
136 :
137 : case 'L':
138 : sendMorseChar(_morse_L, sizeof(_morse_L));
139 : break
140 :
141 : case 'M':
142 : sendMorseChar(_morse_M, sizeof(_morse_M));
143 : break
144 :
145 : case 'N':
146 : sendMorseChar(_morse_N, sizeof(_morse_N));
147 : break
148 :
149 : case 'O':
150 : sendMorseChar(_morse_O, sizeof(_morse_O));
151 : break
152 :
153 : case 'P':
154 : sendMorseChar(_morse_P, sizeof(_morse_P));
155 : break
156 :
157 : case 'Q':
158 : sendMorseChar(_morse_Q, sizeof(_morse_Q));
159 : break
160 :
161 : case 'R':
162 : sendMorseChar(_morse_R, sizeof(_morse_R));
163 : break
164 :
165 : case 'S':
166 : sendMorseChar(_morse_S, sizeof(_morse_S));
167 : break
168 :
169 : case 'T':
170 : sendMorseChar(_morse_T, sizeof(_morse_T));
171 : break
172 :
173 : case 'U':
174 : sendMorseChar(_morse_U, sizeof(_morse_U));
175 : break
176 :
177 : case 'V':
178 : sendMorseChar(_morse_V, sizeof(_morse_V));
179 : break
180 :
181 : case 'W':
182 : sendMorseChar(_morse_W, sizeof(_morse_W));
183 : break
184 :
185 : case 'X':
186 : sendMorseChar(_morse_X, sizeof(_morse_X));
187 : break
188 :
189 : case 'Y':
190 : sendMorseChar(_morse_Y, sizeof(_morse_Y));
191 : break
192 :
193 : case 'Z':
194 : sendMorseChar(_morse_Z, sizeof(_morse_Z));
195 : break
196 : }
197 :
198 : }
199 :
200 : void MorseCode::send(char message[])
201 : {
202 :
203 : int length = strlen(message);
204 : Serial.println("Secret message");
205 :
206 : for (byte i = 0; i < length; i++)
207 : {
208 :
209 : if (message[i] == ' ')
210 : {
211 : Serial.println();
212 : delay (_wordBreak);
213 : }
214 : else
215 : {
216 : if (message[i] >= 'a' && message[i] <= 'z')
217 : {
218 : processLetters(message[i] - 32);
219 : }
220 : else if (message[i] >= 'A' && message[i] <= 'Z')
221 : {
222 : processLetters(message[i]);
223 : }
224 : else if (message[i] >= 48 && message[i] <= 57)
225 : {
226 : processNumbers(message[i]);
227 : }
228 : else if (message[i] == ',' ||message[i] == '.'||message[i] == '?')
229 : {
230 : processPunctuation(message[i]);
231 : }
232 : else
233 : {
234 : Serial.println("ERROR: Unknown Letter....");
235 : }
236 :
237 : Serial.print(" , ");
238 : }
239 : }
240 : Serial.println();
241 : }
242 :
243 : void MorseCode::sendMorseChar(boolean morseValue[], int size)
244 : {
245 : for (int x = 0; x246 : {
247 : if (morseValue[x] == 0)
248 : {
249 : Serial.print(".");
250 : dit();
251 : }
252 : else
253 : {
254 : Serial.print(".");
255 : da();
256 : }
257 : }
258 : }
259 :
260 : void MorseCode::dit ()
261 : {
262 :
263 : if (_ledPin != -1){
264 : digitalWrite(_ledPin, HIGH);
265 : }
266 :
267 : if (_speakerPin != -1){
268 : tone(_speakerPin, _tone, _dit);
269 : }
270 :
271 : delay (_dit);
272 :
273 : if (_ledPin != -1){
274 : digitalWrite(_ledPin, LOW);
275 : }
276 :
277 : delay (_letterBreak);
278 : }
279 :
280 : void MorseCode::da()
281 : {
282 : if (_ledPin != -1){
283 : digitalWrite(_ledPin, HIGH);
284 : }
285 :
286 : if (_speakerPin != -1){
287 : tone(_speakerPin, _tone, _da);
288 : }
289 :
290 : delay (_da);
291 :
292 : if (_ledPin != -1){
293 : digitalWrite(_ledPin, LOW);
294 : }
295 :
296 : delay (_letterBreak);
297 : }
298 :
299 : void MorseCode::calculateTiming (){
300 : _dit = _unitTime;
301 : _da = 3 * _unitTime;
302 : _letterBreak = 3 * _unitTime;
303 : _wordBreak = 7 * _unitTime;
304 : }
305 :
306 :
Source Code
A zip file containing the complete Arduino morse code project
