如何使用Arduino制作摩尔斯电报翻译器

风筝

以编码的方式进行通信，除了迷人之外，在各个领域中具有许多应用。最常见的编码通信方法之一是摩尔斯电码。在本篇文章中，您将学习如何使用Arduino开发板制作一台翻译器来发送和接收摩尔斯电码。

什么是摩尔斯电码？

在过去，通信并不像今天那么简单，最常见的通信方式之一是塞缪尔莫尔斯（Samuel Morse）方法，称为“摩尔斯电码”。在此方法中，每个字母或数字通过使用短（点）和长（破折号）元素表示。

与其他语言一样，摩尔斯电码有自己的字母表，目前有美国和国际两种类型，最常用的是国际类型。

摩尔斯电码可以以不同的方式传输：最初是沿电报线的电脉冲，也可以是音频音、无线电信号、灯光、肢体语言、频率等。想象一下点作为时间单位，然后短划线是三个时间单位，一个字母的部分之间的距离是一个时间单位，两个连续字母之间的距离是三个单位的时间，以及单词之间的距离是七个单位的时间。

例如，SOS这个词，请求帮助的全球标准是......  - 摩尔斯电码。

莫尔斯电码仍然实用吗？

虽然莫尔斯代码不再像过去那样使用，但它仍然有自己的应用程序。摩尔斯电码仍然受到业余无线电领域爱好者的欢迎。摩尔斯电码也用于航空导航系统。许多船只使用莫尔斯电码发送灯光进行通信或帮助。此外，那些因任何原因无法说话的人也可以使用莫尔斯电码来表达其含义。

除此之外，学习和使用莫尔斯电码进行交流可以带来乐趣。

所需的材料

●    Arduino UNO R3开发板

●    有源蜂鸣器

●    LED指示灯

●    跳线

●    Arduino IDE

使用Arduino制作摩尔斯电码编码器

记住莫尔斯代码并将文本转换为此代码可能有点困难，所以让我们让编码器将文本转换为莫尔斯代码！

在这里，我们使用Arduino UNO将文本翻译为摩尔斯电码。在Arduino开发板上上传此代码并打开串口监视器窗口。键入您想要的单词或文本，并使用莫尔斯电码的方式接收，然后您可以将其以光和声音的形式发送。

电路

代码

1. /*
   
2. 
   
3. Morse code - Transmitter
   
4. 
   
5. modified on 14 Apr 2019
   
6. by Saeed Hosseini @ Electropeak
   
7. https://electropeak.com/learn
   
8. 
   
9. */
   
10. 
    
11. const int led = 13;
    
12. const int buz = 8;
    
13. 
    
14. String code = "";
    
15. int len = 0;
    
16. char ch;
    
17. char new_char;
    
18. int unit_delay = 250;
    
19. 
    
20. 
    
21. void dot()
    
22. {
    
23.   Serial.print(".");
    
24.   digitalWrite(led, HIGH);
    
25.   digitalWrite(buz, HIGH);
    
26.   delay(unit_delay);
    
27.   digitalWrite(led, LOW);
    
28.   digitalWrite(buz, LOW);
    
29.   delay(unit_delay);
    
30. }
    
31. 
    
32. void dash()
    
33. {
    
34.   Serial.print("-");
    
35.   digitalWrite(led, HIGH);
    
36.   digitalWrite(buz, HIGH);
    
37.   delay(unit_delay * 3);
    
38.   digitalWrite(led, LOW);
    
39.   digitalWrite(buz, LOW);
    
40.   delay(unit_delay);
    
41. }
    
42. 
    
43. void A()
    
44. {
    
45.   dot();
    
46.   delay(unit_delay);
    
47.   dash();
    
48.   delay(unit_delay);
    
49. }
    
50. void B()
    
51. {
    
52.   dash();
    
53.   delay(unit_delay);
    
54.   dot();
    
55.   delay(unit_delay);
    
56.   dot();
    
57.   delay(unit_delay);
    
58.   dot();
    
59.   delay(unit_delay);
    
60. }
    
61. void C()
    
62. {
    
63.   dash();
    
64.   delay(unit_delay);
    
65.   dot();
    
66.   delay(unit_delay);
    
67.   dash();
    
68.   delay(unit_delay);
    
69.   dot();
    
70.   delay(unit_delay);
    
71. }
    
72. void D()
    
73. {
    
74.   dash();
    
75.   delay(unit_delay);
    
76.   dot();
    
77.   delay(unit_delay);
    
78.   dot();
    
79.   delay(unit_delay);
    
80. }
    
81. void E()
    
82. {
    
83.   dot();
    
84.   delay(unit_delay);
    
85. }
    
86. void f()
    
87. {
    
88.   dot();
    
89.   delay(unit_delay);
    
90.   dot();
    
91.   delay(unit_delay);
    
92.   dash();
    
93.   delay(unit_delay);
    
94.   dot();
    
95.   delay(unit_delay);
    
96. }
    
97. void G()
    
98. {
    
99.   dash();
    
100.   delay(unit_delay);
     
101.   dash();
     
102.   delay(unit_delay);
     
103.   dot();
     
104.   delay(unit_delay);
     
105. }
     
106. void H()
     
107. {
     
108.   dot();
     
109.   delay(unit_delay);
     
110.   dot();
     
111.   delay(unit_delay);
     
112.   dot();
     
113.   delay(unit_delay);
     
114.   dot();
     
115.   delay(unit_delay);
     
116. }
     
117. void I()
     
118. {
     
119.   dot();
     
120.   delay(unit_delay);
     
121.   dot();
     
122.   delay(unit_delay);
     
123. }
     
124. void J()
     
125. {
     
126.   dot();
     
127.   delay(unit_delay);
     
128.   dash();
     
129.   delay(unit_delay);
     
130.   dash();
     
131.   delay(unit_delay);
     
132.   dash();
     
133.   delay(unit_delay);
     
134. }
     
135. void K()
     
136. {
     
137.   dash();
     
138.   delay(unit_delay);
     
139.   dot();
     
140.   delay(unit_delay);
     
141.   dash();
     
142.   delay(unit_delay);
     
143. }
     
144. void L()
     
145. {
     
146.   dot();
     
147.   delay(unit_delay);
     
148.   dash();
     
149.   delay(unit_delay);
     
150.   dot();
     
151.   delay(unit_delay);
     
152.   dot();
     
153.   delay(unit_delay);
     
154. }
     
155. void M()
     
156. {
     
157.   dash();
     
158.   delay(unit_delay);
     
159.   dash();
     
160.   delay(unit_delay);
     
161. }
     
162. void N()
     
163. {
     
164.   dash();
     
165.   delay(unit_delay);
     
166.   dot();
     
167.   delay(unit_delay);
     
168. }
     
169. void O()
     
170. {
     
171.   dash();
     
172.   delay(unit_delay);
     
173.   dash();
     
174.   delay(unit_delay);
     
175.   dash();
     
176.   delay(unit_delay);
     
177. }
     
178. void P()
     
179. {
     
180.   dot();
     
181.   delay(unit_delay);
     
182.   dash();
     
183.   delay(unit_delay);
     
184.   dash();
     
185.   delay(unit_delay);
     
186.   dot();
     
187. }
     
188. void Q()
     
189. {
     
190.   dash();
     
191.   delay(unit_delay);
     
192.   dash();
     
193.   delay(unit_delay);
     
194.   dot();
     
195.   delay(unit_delay);
     
196.   dash();
     
197.   delay(unit_delay);
     
198. }
     
199. void R()
     
200. {
     
201.   dot();
     
202.   delay(unit_delay);
     
203.   dash();
     
204.   delay(unit_delay);
     
205.   dot();
     
206.   delay(unit_delay);
     
207. }
     
208. void S()
     
209. {
     
210.   dot();
     
211.   delay(unit_delay);
     
212.   dot();
     
213.   delay(unit_delay);
     
214.   dot();
     
215.   delay(unit_delay);
     
216. }
     
217. void T()
     
218. {
     
219.   dash();
     
220.   delay(unit_delay);
     
221. }
     
222. void U()
     
223. {
     
224.   dot();
     
225.   delay(unit_delay);
     
226.   dot();
     
227.   delay(unit_delay);
     
228.   dash();
     
229.   delay(unit_delay);
     
230. }
     
231. void V()
     
232. {
     
233.   dot();
     
234.   delay(unit_delay);
     
235.   dot();
     
236.   delay(unit_delay);
     
237.   dot();
     
238.   delay(unit_delay);
     
239.   dash();
     
240.   delay(unit_delay);
     
241. }
     
242. void W()
     
243. {
     
244.   dot();
     
245.   delay(unit_delay);
     
246.   dash();
     
247.   delay(unit_delay);
     
248.   dash();
     
249.   delay(unit_delay);
     
250. }
     
251. void X()
     
252. {
     
253.   dash();
     
254.   delay(unit_delay);
     
255.   dot();
     
256.   delay(unit_delay);
     
257.   dot();
     
258.   delay(unit_delay);
     
259.   dash();
     
260.   delay(unit_delay);
     
261. }
     
262. void Y()
     
263. {
     
264.   dash();
     
265.   delay(unit_delay);
     
266.   dot();
     
267.   delay(unit_delay);
     
268.   dash();
     
269.   delay(unit_delay);
     
270.   dash();
     
271.   delay(unit_delay);
     
272. }
     
273. void Z()
     
274. {
     
275.   dash();
     
276.   delay(unit_delay);
     
277.   dash();
     
278.   delay(unit_delay);
     
279.   dot();
     
280.   delay(unit_delay);
     
281.   dot();
     
282.   delay(unit_delay);
     
283. }
     
284. void one()
     
285. {
     
286.   dot();
     
287.   delay(unit_delay);
     
288.   dash();
     
289.   delay(unit_delay);
     
290.   dash();
     
291.   delay(unit_delay);
     
292.   dash();
     
293.   delay(unit_delay);
     
294.   dash();
     
295.   delay(unit_delay);
     
296. }
     
297. void two()
     
298. {
     
299.   dot();
     
300.   delay(unit_delay);
     
301.   dot();
     
302.   delay(unit_delay);
     
303.   dash();
     
304.   delay(unit_delay);
     
305.   dash();
     
306.   delay(unit_delay);
     
307.   dash();
     
308.   delay(unit_delay);
     
309. }
     
310. void three()
     
311. {
     
312.   dot();
     
313.   delay(unit_delay);
     
314.   dot();
     
315.   delay(unit_delay);
     
316.   dot();
     
317.   delay(unit_delay);
     
318.   dash();
     
319.   delay(unit_delay);
     
320.   dash();
     
321.   delay(unit_delay);
     
322. }
     
323. void four()
     
324. {
     
325.   dot();
     
326.   delay(unit_delay);
     
327.   dot();
     
328.   delay(unit_delay);
     
329.   dot();
     
330.   delay(unit_delay);
     
331.   dot();
     
332.   delay(unit_delay);
     
333.   dash();
     
334.   delay(unit_delay);
     
335. }
     
336. void five()
     
337. {
     
338.   dot();
     
339.   delay(unit_delay);
     
340.   dot();
     
341.   delay(unit_delay);
     
342.   dot();
     
343.   delay(unit_delay);
     
344.   dot();
     
345.   delay(unit_delay);
     
346.   dot();
     
347.   delay(unit_delay);
     
348. }
     
349. void six()
     
350. {
     
351.   dash();
     
352.   delay(unit_delay);
     
353.   dot();
     
354.   delay(unit_delay);
     
355.   dot();
     
356.   delay(unit_delay);
     
357.   dot();
     
358.   delay(unit_delay);
     
359.   dot();
     
360.   delay(unit_delay);
     
361. }
     
362. void seven()
     
363. {
     
364.   dash();
     
365.   delay(unit_delay);
     
366.   dash();
     
367.   delay(unit_delay);
     
368.   dot();
     
369.   delay(unit_delay);
     
370.   dot();
     
371.   delay(unit_delay);
     
372.   dot();
     
373.   delay(unit_delay);
     
374. }
     
375. void eight()
     
376. {
     
377.   dash();
     
378.   delay(unit_delay);
     
379.   dash();
     
380.   delay(unit_delay);
     
381.   dash();
     
382.   delay(unit_delay);
     
383.   dot();
     
384.   delay(unit_delay);
     
385.   dot();
     
386.   delay(unit_delay);
     
387. }
     
388. void nine()
     
389. {
     
390.   dash();
     
391.   delay(unit_delay);
     
392.   dash();
     
393.   delay(unit_delay);
     
394.   dash();
     
395.   delay(unit_delay);
     
396.   dash();
     
397.   delay(unit_delay);
     
398.   dot();
     
399.   delay(unit_delay);
     
400. }
     
401. void zero()
     
402. {
     
403.   dash();
     
404.   delay(unit_delay);
     
405.   dash();
     
406.   delay(unit_delay);
     
407.   dash();
     
408.   delay(unit_delay);
     
409.   dash();
     
410.   delay(unit_delay);
     
411.   dash();
     
412.   delay(unit_delay);
     
413. }
     
414. void morse()
     
415. {
     
416.   if (ch == 'A' || ch == 'a')
     
417.   {
     
418.     A();
     
419.     Serial.print(" ");
     
420.   }
     
421.   else if (ch == 'B' || ch == 'b')
     
422.   {
     
423.     B();
     
424.     Serial.print(" ");
     
425.   }
     
426.   else if (ch == 'C' || ch == 'c')
     
427.   {
     
428.     C();
     
429.     Serial.print(" ");
     
430.   }
     
431.   else if (ch == 'D' || ch == 'd')
     
432.   {
     
433.     D();
     
434.     Serial.print(" ");
     
435.   }
     
436.   else if (ch == 'E' || ch == 'e')
     
437.   {
     
438.     E();
     
439.     Serial.print(" ");
     
440.   }
     
441.   else if (ch == 'f' || ch == 'f')
     
442.   {
     
443.     f();
     
444.     Serial.print(" ");
     
445.   }
     
446.   else if (ch == 'G' || ch == 'g')
     
447.   {
     
448.     G();
     
449.     Serial.print(" ");
     
450.   }
     
451.   else if (ch == 'H' || ch == 'h')
     
452.   {
     
453.     H();
     
454.     Serial.print(" ");
     
455.   }
     
456.   else if (ch == 'I' || ch == 'i')
     
457.   {
     
458.     I();
     
459.     Serial.print(" ");
     
460.   }
     
461.   else if (ch == 'J' || ch == 'j')
     
462.   {
     
463.     J();
     
464.     Serial.print(" ");
     
465.   }
     
466.   else if (ch == 'K' || ch == 'k')
     
467.   {
     
468.     K();
     
469.     Serial.print(" ");
     
470.   }
     
471.   else if (ch == 'L' || ch == 'l')
     
472.   {
     
473.     L();
     
474.     Serial.print(" ");
     
475.   }
     
476.   else if (ch == 'M' || ch == 'm')
     
477.   {
     
478.     M();
     
479.     Serial.print(" ");
     
480.   }
     
481.   else if (ch == 'N' || ch == 'n')
     
482.   {
     
483.     N();
     
484.     Serial.print(" ");
     
485.   }
     
486.   else if (ch == 'O' || ch == 'o')
     
487.   {
     
488.     O();
     
489.     Serial.print(" ");
     
490.   }
     
491.   else if (ch == 'P' || ch == 'p')
     
492.   {
     
493.     P();
     
494.     Serial.print(" ");
     
495.   }
     
496.   else if (ch == 'Q' || ch == 'q')
     
497.   {
     
498.     Q();
     
499.     Serial.print(" ");
     
500.   }
     
501.   else if (ch == 'R' || ch == 'r')
     
502.   {
     
503.     R();
     
504.     Serial.print(" ");
     
505.   }
     
506.   else if (ch == 'S' || ch == 's')
     
507.   {
     
508.     S();
     
509.     Serial.print(" ");
     
510.   }
     
511.   else if (ch == 'T' || ch == 't')
     
512.   {
     
513.     T();
     
514.     Serial.print(" ");
     
515.   }
     
516.   else if (ch == 'U' || ch == 'u')
     
517.   {
     
518.     U();
     
519.     Serial.print(" ");
     
520.   }
     
521.   else if (ch == 'V' || ch == 'v')
     
522.   {
     
523.     V();
     
524.     Serial.print(" ");
     
525.   }
     
526.   else if (ch == 'W' || ch == 'w')
     
527.   {
     
528.     W();
     
529.     Serial.print(" ");
     
530.   }
     
531.   else if (ch == 'X' || ch == 'x')
     
532.   {
     
533.     X();
     
534.     Serial.print(" ");
     
535.   }
     
536.   else if (ch == 'Y' || ch == 'y')
     
537.   {
     
538.     Y();
     
539.     Serial.print(" ");
     
540.   }
     
541.   else if (ch == 'Z' || ch == 'z')
     
542.   {
     
543.     Z();
     
544.     Serial.print(" ");
     
545.   }
     
546.   else if (ch == '0')
     
547.   {
     
548.     zero();
     
549.     Serial.print(" ");
     
550.   }
     
551.   else if (ch == '1')
     
552.   {
     
553.     one();
     
554.     Serial.print(" ");
     
555.   }
     
556.   else if (ch == '2')
     
557.   {
     
558.     two();
     
559.     Serial.print(" ");
     
560.   }
     
561.   else if (ch == '3')
     
562.   {
     
563.     three();
     
564.     Serial.print(" ");
     
565.   }
     
566.   else if (ch == '4')
     
567.   {
     
568.     four();
     
569.     Serial.print(" ");
     
570.   }
     
571.   else if (ch == '5')
     
572.   {
     
573.     five();
     
574.     Serial.print(" ");
     
575.   }
     
576.   else if (ch == '6')
     
577.   {
     
578.     six();
     
579.     Serial.print(" ");
     
580.   }
     
581.   else if (ch == '7')
     
582.   {
     
583.     seven();
     
584.     Serial.print(" ");
     
585.   }
     
586.   else if (ch == '8')
     
587.   {
     
588.     eight();
     
589.     Serial.print(" ");
     
590.   }
     
591.   else if (ch == '9')
     
592.   {
     
593.     nine();
     
594.     Serial.print(" ");
     
595.   }
     
596.   else if(ch == ' ')
     
597.   {
     
598.     delay(unit_delay*7);
     
599.     Serial.print("/ ");
     
600.   }
     
601.   else
     
602.     Serial.println("Unknown symbol!");
     
603. }
     
604. 
     
605. void String2Morse()
     
606. {
     
607.   len = code.length();
     
608.   for (int i = 0; i < len; i++)
     
609.   {
     
610.     ch = code.charAt(i);
     
611.     morse();
     
612.   }
     
613. }
     
614. 
     
615. void setup() {
     
616.   Serial.begin(9600);
     
617.   pinMode(led, OUTPUT);
     
618.   pinMode(buz, OUTPUT);
     
619.   Serial.println("I am ready...");
     
620. }
     
621. 
     
622. void loop() {
     
623.   while (Serial.available())
     
624.   {
     
625.     code = Serial.readString();
     
626.     Serial.print(code);
     
627.     Serial.print(" = ");
     
628.     String2Morse();
     
629.     Serial.println("");
     
630.   }
     
631.   delay(1000);
     
632. }

复制代码

使用Arduino制作摩尔斯电码解码器

在另一种情况下，您是莫尔斯电码的收件人，您必须将收到的代码转换为文本。

要模拟这一点，请使用密钥将摩尔斯电码发送到Arduino，并在串口监视器中将看到文本形式的结果。

电路

代码

1. /*
   
2. 
   
3.   Morse code - Receiver
   
4. 
   
5.   modified on 14 Apr 2019
   
6.   by Saeed Hosseini @ Electropeak
   
7.   https://electropeak.com/learn
   
8. 
   
9. */
   
10. 
    
11. String code = "";
    
12. int len = 0;
    
13. char ch;
    
14. char new_char;
    
15. 
    
16. const int but = 2;
    
17. const int led = 13;
    
18. 
    
19. unsigned long pres_len = 0, rel_time, pres_time = 0, old_time_len = 0, old_pres = 0, space = 0;
    
20. int state = 0;
    
21. int unit_delay = 250;
    
22. int min_delay = 10;
    
23. 
    
24. char MakeString()
    
25. {
    
26.   if (pres_len < (unit_delay*3) && pres_len > 50)
    
27.   {
    
28.     return '.';                        //if button press less than 0.6sec, it is a dot
    
29.   }
    
30.   else if (pres_len > (unit_delay*3))
    
31.   {
    
32.     return '-';                        //if button press more than 0.6sec, it is a dash
    
33.   }
    
34. }
    
35. 
    
36. void Morse_decod()
    
37. {
    
38.   static String morse[] = {".-", "-...", "-.-.", "-..", ".", "..-.", "--.", "....",
    
39.                              "..", ".---", "-.-", ".-..", "--", "-.", "---", ".--.", "--.-",
    
40.                              ".-.", "...", "-", "..-", "...-", ".--", "-..-", "-.--", "--..", "!"
    
41.                             };
    
42.   int i = 0;
    
43.   while (morse[i] != "!")  
    
44.   {
    
45.     if (morse[i] == code)
    
46.     {
    
47.       Serial.print(char('A' + i));
    
48.       Serial.print(" ");
    
49.       break;
    
50.     }
    
51.     i++;
    
52.   }
    
53.   if (morse[i] == "!")
    
54.   {
    
55.     Serial.println("");
    
56.     Serial.println("This code is not exist!");
    
57.   }
    
58. 
    
59.   code = "";
    
60. }
    
61. 
    
62. void setup() {
    
63.   Serial.begin(9600);
    
64.   pinMode(but, INPUT_PULLUP);
    
65.   pinMode(led, OUTPUT);
    
66. 
    
67. }
    
68. void loop() {
    
69. label:
    
70.   while (digitalRead(but) == HIGH) {}
    
71.   old_pres = rel_time;
    
72.   pres_time = millis();
    
73.   digitalWrite(led, HIGH);
    
74.   while (digitalRead(but) == LOW) {}
    
75.   rel_time = millis();
    
76.   digitalWrite(led, LOW);
    
77.   pres_len = rel_time - pres_time;
    
78.   space = pres_time - old_pres;
    
79.   if (pres_len > min_delay)
    
80.   {
    
81.     code += MakeString();
    
82.   }
    
83.   while ((millis() - rel_time) < (unit_delay * 3))
    
84.   {
    
85.     if (digitalRead(but) == LOW)
    
86.     {
    
87.       goto label;
    
88.     }
    
89.   }
    
90. 
    
91.   Morse_decod();
    
92. }

复制代码

以上就是本篇文章的全部内容。如有问题，请随时在本帖下面进行回复。