自动摩斯电码接收器

树·水·风

前一段时间看《终极审判》，潜水员利用声音发送摩斯电码给潜艇最终获救，于是突发灵感：既然普通人无法记住每个字幕的摩斯电码，何不做一个自动接收器，将白光闪烁信号解析为字母呢？于是就开始做了。
整个系统包括两个部分：发送端和接收端。
发送端，使用Arduino控制LED手电发出闪光。MorseCode库参见程晨老师的Arduino开发实战指南，我所做的是在上面加了一些扩充。
Arduino代码如下：

1. /*
   
2. @Date:2012/11/10
   
3. @Author:huaweidong
   
4. @Description:MorseDemo03-自定义字符串，每次接收到的新的字符串替换原先的字符串，并开始循环发送
   
5. */
   
6. #include "MorseCode.h"
   
7. char words[20];
   
8. int i = 0;
   
9. MorseCode Morse(13);
   
10. 
    
11. void setup()
    
12. {
    
13.   Morse.setInterval(250);
    
14.   Serial.begin(9600);
    
15. }
    
16. 
    
17. void loop()
    
18. {
    
19.   if(Serial.available())
    
20.   {
    
21.     i = 0;
    
22.     while(Serial.available())
    
23.     {
    
24.       words[i] = Serial.read();
    
25.       i++;
    
26.     }
    
27.   }
    
28.   int k;
    
29.   for(k = 0; k < i; k++)
    
30.   {
    
31.     Serial.print(words[k]);
    
32.     if(words[k] == ' ')
    
33.     {
    
34.        Morse.WordInterval();
    
35.     }
    
36.     else
    
37.     {
    
38.       Morse.transfor(words[k]);
    
39.       Morse.CharInterval();
    
40.     }
    
41.   }
    
42.   Serial.println();
    
43.   Morse.WordInterval();
    
44. }
    

复制代码

用户打开串口工具后，可以自定义字符串（可包含空格），发送到Arduino板中，如SOS，Arduino之后便会循环发送SOS，直到用户输入新的字符串替换到原有字符串。

我使用的设备是小手电（原本想使用Android手机的闪光灯的，但是发现Android的闪光灯无法单独调用，只能连摄像头一起开启，而一旦开启摄像头，那么闪光灯的响应速度就变得很慢，无法达到想要的效果），原想使用三极管放大电路从而让Arduino控制小手电，后来发现小手电的额定电压也不过4.5V，于是就直接把小手电插在了Arduino板上。如下图所示：
图中小手电显示这么灰暗是因为我用手机拍照的缘故，实际上小手电的亮度是足够的（14个led灯），在夜间测试20米远完全没有问题。

于是摩斯电码发送端就算做好了，小手电可以发出间歇性的"."和"_"了，信息就存在与这些间歇性的闪光中。

下面就是接收端。

接收端我用的是一个摄像头，利用计算机视觉的方法，检测视频图像的颜色信息，根据颜色变化确定"."和"_"，然后进一步确定每个英文字符，最后组成一个单词。
代码如下（未经优化，有很多冗余代码，大家见谅）：

1. #include <stdio.h>
   
2. #include <cv.h>
   
3. #include <highgui.h>
   
4. #include <cxcore.h>
   
5. #include <process.h>
   
6. #include <Windows.h>
   
7. #include <iostream>
   
8. 
   
9. using namespace std;
   
10. 
    
11. IplImage* IFrameBody = 0;
    
12. IplImage* gray = 0;
    
13. int red_cnt;
    
14. int no_cnt;
    
15. bool state;
    
16. bool last_state;
    
17. short value = 1;
    
18. int height, width;
    
19. CvCapture* pcap;
    
20. 
    
21. char Decide(short i)
    
22. {
    
23.         char ch = '*';
    
24.         switch(i){
    
25.         case 5:
    
26.                 ch = 'A';
    
27.                 break;
    
28.         case 24:
    
29.                 ch = 'B';
    
30.                 break;
    
31.         case 26:
    
32.                 ch = 'C';
    
33.                 break;
    
34.         case 12:
    
35.                 ch = 'D';
    
36.                 break;
    
37.         case 2:
    
38.                 ch = 'E';
    
39.                 break;
    
40.         case 18:
    
41.                 ch = 'F';
    
42.                 break;
    
43.         case 14:
    
44.                 ch = 'G';
    
45.                 break;
    
46.         case 16:
    
47.                 ch = 'H';
    
48.                 break;
    
49.         case 4:
    
50.                 ch = 'I';
    
51.                 break;
    
52.         case 23:
    
53.                 ch = 'J';
    
54.                 break;
    
55.         case 13:
    
56.                 ch = 'K';
    
57.                 break;
    
58.         case 20:
    
59.                 ch = 'L';
    
60.                 break;
    
61.         case 7:
    
62.                 ch = 'M';
    
63.                 break;
    
64.         case 6:
    
65.                 ch = 'N';
    
66.                 break;
    
67.         case 15:
    
68.                 ch = 'O';
    
69.                 break;
    
70.         case 22:
    
71.                 ch = 'P';
    
72.                 break;
    
73.         case 29:
    
74.                 ch = 'Q';
    
75.                 break;
    
76.         case 10:
    
77.                 ch = 'R';
    
78.                 break;
    
79.         case 8:
    
80.                 ch = 'S';
    
81.                 break;
    
82.         case 3:
    
83.                 ch = 'T';
    
84.                 break;
    
85.         case 9:
    
86.                 ch = 'U';
    
87.                 break;
    
88.         case 17:
    
89.                 ch = 'V';
    
90.                 break;
    
91.         case 11:
    
92.                 ch = 'W';
    
93.                 break;
    
94.         case 25:
    
95.                 ch = 'X';
    
96.                 break;
    
97.         case 27:
    
98.                 ch = 'Y';
    
99.                 break;
    
100.         case 28:
     
101.                 ch = 'Z';
     
102.                 break;
     
103.         default:
     
104.                 ch = '*';
     
105.                 break;
     
106.         }
     
107.         return ch;
     
108. }
     
109. 
     
110. int main(int argc, char* argv[])
     
111. {
     
112.         CvCapture* pCapBody = cvCreateCameraCapture(1);
     
113. 
     
114.         if(pCapBody == NULL)
     
115.         {
     
116.                 printf("No body camera!!!!!!!!\n");
     
117.         }
     
118.        
     
119.         red_cnt = 0;
     
120.         no_cnt = 0;
     
121.         state = false;        // false代表无色，true代表检测到白色
     
122.         last_state = false;
     
123. 
     
124.         while(1)
     
125.         {
     
126.                 IFrameBody = cvQueryFrame(pCapBody);
     
127.                 if(IFrameBody == NULL)
     
128.                 {
     
129.                         printf("No Pictures.\n");
     
130.                 }
     
131. 
     
132.                 height = IFrameBody->height;
     
133.                 width = IFrameBody->width;
     
134.                 gray = cvCreateImage(cvSize(width,height),8,1);        // 创建灰度图像
     
135. 
     
136.                 int count = 0;
     
137. 
     
138.                 /* 检测白色光 */
     
139.                 cvCvtColor(IFrameBody, gray, CV_BGR2GRAY);
     
140.                 for(int i = 220; i < 320; i++)
     
141.                 {
     
142.                         for(int j = 300; j < 400; j++)
     
143.                         {
     
144.                                 int g = ((uchar*)(gray->imageData+gray->widthStep*j))[i];
     
145.                                 if(g>150)
     
146.                                 {
     
147.                                         count += 1;
     
148.                                         ((uchar*)(gray->imageData+gray->widthStep*j))[i] = 255;
     
149.                                 }
     
150.                                 else
     
151.                                 {
     
152.                                         ((uchar*)(gray->imageData+gray->widthStep*j))[i] = 0;
     
153.                                 }
     
154.                         }
     
155.                 }
     
156. 
     
157.                 if(count > 1500)        // 检测“白色”，1500是像素点阈值
     
158.                 {
     
159.                         state = true;
     
160.                         if(last_state == false)
     
161.                         {
     
162.                                 if(no_cnt > 10 && no_cnt < 35)        // 说明是字符间间隔,no_cnt是持续检测到“无色”的次数，10和35是阈值
     
163.                                 {
     
164.                                         cout<<Decide(value);
     
165.                                         value = 1;
     
166.                                 }
     
167.                                 else if(no_cnt > 35)        // 说明是单词间间隔
     
168.                                 {
     
169.                                         cout<<Decide(value)<<" ";
     
170.                                         value = 1;
     
171.                                 }
     
172.                                 no_cnt = 0;
     
173.                                 red_cnt = 0;
     
174.                         }
     
175.                         red_cnt++;
     
176.                 }
     
177.                 else        // 检测到“无色”
     
178.                 {
     
179.                         state = false;
     
180.                         if(last_state == true)
     
181.                         {
     
182.                                 if(red_cnt >= 10)        // 检测到“白色”十次以上，判断为“_”，阈值10可调
     
183.                                 {
     
184.                                         value = (value << 1) + 1;
     
185.                                 }
     
186.                                 else if(red_cnt < 10)        // 检测到“白色”的时间很短，判断为“.”
     
187.                                 {
     
188.                                         value = value << 1;
     
189.                                 }
     
190.                                 red_cnt = 0;
     
191.                                 no_cnt = 0;
     
192.                         }
     
193.                         no_cnt++;
     
194.                 }
     
195. 
     
196.                 last_state = state;
     
197.                
     
198.                 cvShowImage("gray", gray);
     
199. 
     
200.                 cvReleaseImage(&gray);
     
201. 
     
202.                 char c=cvWaitKey(1);
     
203.                 if(c==27)break;
     
204.         }
     
205. 
     
206.         cvReleaseCapture(&pCapBody);
     
207. 
     
208. }
     

复制代码

上面一些阈值（如区分"."与"_"以及空格）需要根据电脑运行速度来设定。
为了提高视频处理速度，我只是对视频整个画面的一小部分做颜色判断，做实验时也把手电和摄像头离得比较近，当距离较远时，就需要把手电正对着摄像头，这样才能检测明显。
最后，执行上面的C++程序，便可以跳出两个窗口，如下图所示

一个窗口显示视频画面，一个输出解析的字母。（细致的同学会发现出现了一个E，这是由于我用手拿着手电遮挡了所造成的，后面就稳定地输出CCNT PVC了。）

发送端和接收端做好后，就可以拿到空旷的场地试验了。

test01

强
还以为是通常光敏电阻做的

ninjiafan

好...摩斯码确实比较有意思...

ttyp

接收端是电脑+摄像头？我还以为也是arduino呢

树·水·风

ttyp 发表于 2012-11-16 09:00
接收端是电脑+摄像头？我还以为也是arduino呢

嗯，感觉摄像头检测效果蛮好的。不知道光敏电阻效果如何，以后有机会可以尝试下。

迷你强

准备做射频版本的。。。

ttyp

树·水·风 发表于 2012-11-16 09:02
嗯，感觉摄像头检测效果蛮好的。不知道光敏电阻效果如何，以后有机会可以尝试下。

摄像头的可以近似模拟人眼吧，我是说使用pc，如果使用arduino+摄像头的的就好了

另外光敏的距离有要求，方向性也差，如果使用激光，距离不错，方向性更差

树·水·风

ttyp 发表于 2012-11-16 10:47
摄像头的可以近似模拟人眼吧，我是说使用pc，如果使用arduino+摄像头的的就好了

另外光敏的距离有要求 ...

假如能够不使用电脑，直接使用Arduino或者其他嵌入式PC，加上摄像头，的确会便携很多，惟一的问题是嵌入式平台上能否支持视频处理。

树·水·风

迷你强 发表于 2012-11-16 09:44
准备做射频版本的。。。

射频？使用无线吗？

迷你强

树·水·风 发表于 2012-11-16 12:28
射频？使用无线吗？

应该是的。。。目前只是构思。。。。

树·水·风

ttyp 发表于 2012-11-16 10:47
摄像头的可以近似模拟人眼吧，我是说使用pc，如果使用arduino+摄像头的的就好了

另外光敏的距离有要求 ...

使用光敏电阻可以做吗？假如想要检测近距离红色的或者蓝色的LED灯的话？

ttyp

树·水·风 发表于 2012-11-20 16:54
使用光敏电阻可以做吗？假如想要检测近距离红色的或者蓝色的LED灯的话？

光敏只能检测光的强度，颜色分辨不了的。有分辨颜色的传感器

bg5cdu

如果可以做成音频版的，再加个1602显示输出就完美了。

ttyp

bg5cdu 发表于 2012-11-21 12:08
如果可以做成音频版的，再加个1602显示输出就完美了。

哈哈，这个想法不错，偷号码的利器

bg5cdu

ttyp 发表于 2012-11-21 14:06
哈哈，这个想法不错，偷号码的利器

怎么成偷号码了，莫尔斯电码和手机脉冲音频不一样的好伐。