基于Arduino的摩尔斯电码练习及无线收发报训练器

gangguo

    摩尔斯电码是一种国际通用的信号代码，以“点”和“划”的组合对字母、数字、符号进行编码，它可以利用电台的载波进行传输，也可以利用声音、图形来进行信息传递。一直以来，摩尔斯码都是一种重要的通信方式，在航空、航天、航海等领域都有不可取代的地位，目前也是无线电爱好者进行通联“必备软件”。用电台进行摩尔斯码的抄报与发报需要进行大量的训练才能达到正常使用的水平，因此，摩尔斯电码练习器是不可或缺的。而目前市面上的练习器，主要有两种：一种只可以通过听来练习；一种可以听，可以解码显示，接电台可以进行发报。笔者在进行练习时想到，能不能开发一种可以听、可以显示，而且不接电台就可以进行模拟收发报的训练器（要持有电台并且使用电台要经历一个比较漫长的过程）。因此，笔者开发这一套基于Arduino的、带2.4G无线传输功能的摩尔斯电码练习器。

收发报演示视频：

自动播报演示视频：

  系统硬件组成

本文使用的处理核心为Arduino NANO板，其搭载的ATmega328单片机足以完成系统功能。由于系统需具备较高的实时性，电键信号使用NANO板的外部中断0即D2引脚来进行采集，电键实质上就是一个开关，因此构建一个开关电路，当电键按下时为高电平，放开时为低电平。为了防止由于电压波动产生误中断，在信号与地之间加入了滤波电容，如下图：

屏幕显示选用了IIC接口的LCD2004液晶显示屏幕。该屏幕有4行显示区，每行可显示20个字符。因此将屏幕分为上下两个显示区，第1、2行显示发送或本机电键输入的电码字符，第3、4行显示接收到的电码字符，界面设计如下图所示：

声音播放用NANO的D3口进行控制，即高电平时发声，低电平时停止发声。声源可由有源蜂鸣器提供。本文选用NE555芯片产生音频脉冲，D3口驱动继电器模块（本文中继电器使用是成品模块）通断，控制脉冲信号的通断以驱动喇叭发声，同时喇叭音量、音调可以通过电位器进行调节。电路原理图如下：

       无线传输部分使用的是UART接口的数据透明传输模块，工作频率为2.4GHz。该模块由于使用的是UART传输，只需要连接TX和RX，简化了硬件结构，同时程序设计也相对简化了，只要设置好波特率和通讯协议即可。接下来开始介绍软件设计思想。

PPM采集到摩尔斯电码的转换

1） 摩尔斯码与PPM的联系

     摩尔斯码由“点”和 “划”组合而成，例如字母“a”,它对应的摩尔斯码为“·–”，字母“B”对应的摩尔斯码为“–···”。而以电键输入摩尔斯码时，则以电键按下的时间长短来表示点和划。如输入“·”时按下电键的时间大约为0.04秒左右，得到的是一个宽度大约0.04秒的脉冲，输入“–”的时间大约是0.15秒，得到的是一个宽度为0.15秒的脉冲信号。因此，以电键输入一个摩尔斯电码，实质上就是形成了一串由多个宽度不一的脉冲组合而成的脉冲序列，这个脉冲序列就构成了一个PPM信号（脉冲位置调制信号）。如下图所示：

不同的字母对应不同的点划组合，从而对应着各不相同的PPM序列，只要能够正确采样这些PPM信号，就可以解析出电键所输入的摩尔斯电码。

2） 采样PPM解析摩尔斯码

a)  PPM采样方法

    PPM采样的关键在于获得各高、低电平脉冲的宽度及其在脉冲序列中的位置。Arduino NANO的外部中断可以捕捉外部电平跳变，并且Arduino官方库中的micros()函数调用时可以读取到系统从开机到当前所经历的微秒数，有了这两个工具则可以非常方便地进行PPM采样。方法如下：首先，将Arduino的外部中断0的触发方式设置为跳变触发，即脉冲的上升沿和下降沿都能触发中断，每次中断到来，就调用micros()函数读取一个当前时刻，但这个时刻必须区分是上升沿时刻还是下降沿时刻，才能计算脉冲的宽度，例如第一个下降沿的时刻减去第一个上升沿的时刻，就能计算出第一个脉冲的宽度；第二个上升沿的时刻减去第一个下降沿的时刻，就能计算出第一个低电平间隔的宽度（或称为负脉冲）。值得注意的是，为什么还要采集低电平的时间呢？低电平对于解码的意义不大，但由于我们要在接收端“复现”发射端电键输入的声音，因此必须采集低电平间隔，才能在接收端“一比一”地复现电键音。为了实现PPM的完全采集，可以在进入中断后读取D2引脚上的电平：如果是高电平，则本次中断是上升沿触发；如果是低电平，则是下降沿触发，如此在不同的触发状态下分别记录上升沿时刻及下降沿时刻，则可以计算正负脉冲的宽度。同时，在每个上升沿置高D3引脚，在每个下降沿置低D3引脚，从而控制喇叭按照电键输入的电码播放声音。

接下来，继续深入地来看如何处理PPM。摩尔斯码是由点和划组合得来，但所有字母的点划组合中点和划的总数不是一定的，例如：A的点划总数是两个（·–），B的点划总数是四个（–···），D的点划总数是三个（–··），E的点划总数是一个（·），所有数字长码的点划总数为五个，一些标点符号为6个，那么每一次采样，应该如何来存储这些PPM数据呢？本文中使用的方法是将所有电码的点划总数按七个点划处理，增加的一位是为了方便加入功能转换编码（例如长码转数字短码，自动播报启动），将七个正脉冲数据存储于一个数组中（代码中的in_code[]），将间隔的6个负脉冲数据存储于另一个数组中（代码中的in_l_code[]）。那么，是不是每一次采集都要等待采集7个正脉冲呢？比如电键输入“A”，实质上只需采集到两个正脉冲及一个间隔负脉冲就完成了采集，假如紧接着输入“B”，那么：1、输入A时如何判断输入完毕；2、接着输入B，B和A之间是否加入空格？为了解决这个问题，就必须建立两个判断机制，首先是判断字码输入完毕，然后是判断两个输入的字码之间是否存在空格。

这两个判断机制，可以建立在时间间隔的基础上。对于一个相对标准的发报手法，点和划的长度、点和划之间的间隔、字码间的间隔都可以得到一个比较固定的时间范围，因此，可以在每个下降沿到来后置位一个标志位，用于控制定时计数的启动，如果定时计数达到设定的阈值（设定好的字码间隔），那么表示该字码输入完毕；如果在正常的点划间隔内能够进入下一次中断（上升沿触发），那么定时计数标志位会被清除，停止计数；另外，在每一个下降沿到来时，用另一个计数值来记录采集到正脉冲的个数，如果定时计数被清除，那么正脉冲记录值从0加到6时则表示7个点划采集完毕，即字码输入完毕。字码输入完毕后，置位相应的标志为，进行解码、显示并且发送数据了。完成了一个字码的显示后，下一个字码的显示位置默认是加1，并且置位空格检测标志位，同样是利用定时计数的方法，如果计数未达到设定的阈值，由于上升沿触发中断，那么空格检测标志位及计数会被清零，那么这个字码就会紧挨着上一个字码显示；如果计数值达到了设定的阈值，则把在原有的显示位置上再加1，那么下一个输入的字码与上一个字码间会增加一个空格。以上的检测过程在一个1毫秒的定时中断函数中处理。经过大量数据样本采集及实际测试，字码间的间隔时间阈值设定为150毫秒比较合适，空格符加入的时间间隔阈值设定为200毫秒较为合适。调整这两个阈值，也可以起到调节发报速度的作用，对于初学发报的可以适当调大两个值。对于发报较为熟练的可以适当减小两个值。

     

外部中断处理代码

定时中断处理代码

b)  PPM数据解析摩尔斯码

将PPM数据解析为摩尔斯码，要经过两个步骤：1、将PPM按位置量化为二进制编码，每一个PPM序列量化为一个14个位的编码，并用一个16位的变量来存储这个编码；2、根据编码映射摩尔斯码。

为实现第一个步骤，笔者对点和划的脉冲宽度以及间隔时间进行了大量采样（数据样本来源于发报速度较为标准的资深无线电爱好者），下面是点和划的部分采样值，单位为微秒。

“点”脉宽采样值

“划”脉宽采样值

从以上数据可以看到，“点”的脉宽在40000-60000微秒之间（0.04秒-0.06秒），“划”的脉宽在150000—300000微秒之间（0.15秒-0.3秒）。由于不同的使用者发报手法不同，得到的点划脉宽也不相同，为了提高系统的识别率，放宽了脉冲的范围：50—120000微秒（0.00005秒—0.12秒）识别为“点”，大于120000但小于450000微秒（0.12秒—0.45秒）识别为“划”，其余的都识别为错误输入。确定好了脉宽范围以后，接下来对PPM信号进行量化编码。在一个16位的二进制编码中，以0-13位（最低位为第0位）来存放编码，每两位的组合来表示一个点划位，以“01”表示“点”，“11”表示划，“00”表示空位，存放顺序为：电码先输入的放在二进制的低位，后输入的依次往高位存放，则字码“A”对应的二进制编码为：00 00 00 00 00 00 11 01 （·–），转换为十六进制为：0x000d；“B”对应的二进制编码为：0000 00 00 01 01 01 11（–···），转换为十六进制为：0x0057。将所有字码按照这个规则转换为十六进制编码，当采集完一个PPM序列后按上述规则进行量化编码，将量化得到的编码放入到“switch”结构中进行判断，就可以快速地得出当前电键输入的字码，如经过对比没有找到对应的编码，则判断为输入错误，在屏幕上会显示“*”提示。下面是功能程序段：

PPM—量化编码示例代码

摩尔斯字码提取示例代码

串口数据发送

电键PPM采集、解码显示的同时，还要将电键PPM数据、摩尔斯码以及空格信息发送到接收端，其中PPM数据用于“复现”发射端的电键音。在采集PPM数据时，采样的是脉冲宽度的微秒数，存储这些数据使用了“long int”长整形变量，这样的一个变量是32位的，占4个字节，而发送时一次是发送一个字节，为了提高效率，首先对PPM数据进行“压缩”，一个简单的办法就是直接除以1000，这样就等同于发送PPM的毫秒数，接收端用毫秒数据来播报电键音与原电键音相差仅是微秒级的，不影响效果，并且经过压缩，一个脉冲宽度数据就可以缩减为16位，即两个字节，这样极大地减少了发送的数据量，更重要的是：有效数据位实际不足16位，因为正常的点划输入，脉冲宽度最多达到0.45秒，即450毫秒，将“450”转换为二进制为：111000010，只占到了9位，这样一来给通讯协议的制定带来了方便之处。

采集到的PPM数据包括7个正脉冲和6个负脉冲，经过“压缩”后放在13个16位的变量中，然后将它们“拆”成26个字节，并且按照制定好的通讯协议“摆放”到数据帧中。整个数据帧的长度为30个字节，其中第“0”字节为“帧头”—0xf0，第“1”字节到第“26”字节存放PPM数据，“27”-“28”字节存放摩尔斯字码的二进制编码，最后一个字节存放“显示空格标志”，当其值为0x01时不空格，0x03时插入空格。为了让数据字节中不出现“0xf0”，在“拆”数据时作了一些处理。由于PPM数据经压缩后实际有效位只有9位， 因此可以将这个数据的“低7位”提取出来（&0x007f）放到一个字节中，剩下的“右移7位”(先&0xff80,后>>7)放到另一个字节中，这样一来就可以保证每个数据字节的最高位保持为“0”即不会出现与帧头重复的“0xf0”，以保证接收端能够准确地解析数据。

数据拆分示意图

数据帧协议示意图

数据处理流程:

1、  从外部中断采集电键输入的PPM序列，将采集到的正负脉宽依次放置于数组“in_code[]”中，in_code[]的数据首先被用于解析摩尔斯码的二进制编码，放置于16位变量mos_code中；

2、将in_code[]数组（正脉冲）及in_l_code[]数组（负脉冲）中的数据“压缩”，依次放置在数组“val[]”中，正负脉冲的排列顺序按照PPM的时序排列；

3、将val[]数组中的各元素及mos_code进行拆分提取，放置于“s_date[]”数组中（从第1字节至第28字节），第0字节放置帧头0xf0，末尾放置空格标志。然后依次从串口发送数据。数据发送完毕后，清空所有数组，准备进行下一轮数据处理。

数据处理及发送代码

串口接收数据

制定好了通讯协议，串口收到数据后就可以准确无误地进行数据解析了。在Arduino官方库中，可以用串口事件来接收处理数据，类似于串口中断的效果。为了提高系统的实时性，串口接收数据利用串口事件来处理。当串口收到数据后，先判断串口缓冲区的字节数是否满足30个字节，如果满足这个条件，则进行数据判读。进入数据判读，首先是要寻找“帧头-0xf0”，找到它之后，紧随其后的29个字节就是我们需要的数据字节。整个接收处理过程就是发送的“逆过程”。首先是将“整理”好的30个字节依次放入“r_date[]”中，然后按照帧协议将第1-26字节的数据“合成”，放入“r_val[]”数组中，这个就是发送端采集到的PPM脉宽数据，这个数据用于“一比一”地播放发送端的电键音。第27、28字节则“合成”摩尔斯码的二进制编码，29字节决定了当前收到的字符前面是否加入空格，最后在LCD屏幕的接收区显示。

串口接收、处理数据代码

         从以上所有代码中可以看到，电键采集以及数据接收都受到一个标志位“by_flag”的限制，这个标志为0时，可以正常收发报，当电键输入特定的功能码时，它会被置1时，系统会进入字码自定播报模式，即自动播报“A-B,0-9”的摩尔斯码，此时不响应任何操作，自动播报完毕后该标志位会清0，恢复到正常收发报模式。另外，系统还支持国际通用字码及数字短码模式的切换，这些切换都是通过电键输入特定的功能编码实现的。

总结

该训练器目前能够满足发报训练的要求，可以让初学者的发报速度接近标准速度。但系统还有很多地方可以改进优化。1、对于过长的“划”输入（电键按下不放）会造成数据帧的数据位溢出，从而在解码端出现电键音“失真”，目前还需要找到更好的方法来解决这个问题。2、在电键连续输入字码时，发报的速度需与系统的识别速度高度吻合，发报过快会出现输入错误提示，太慢又会加入空格，此问题还需进一步优化解决。3、目前系统只支持手动键输入，后续还需增加自动键识别功能。

源码如下：

1. /********************************************V1.1.0正式版***********************************************************************/
   
2. #include<Timer.h>
   
3. Timer t;
   
4. #include <Wire.h>
   
5. #include <LiquidCrystal_I2C.h>
   
6. LiquidCrystal_I2C lcd(0x27,20,4);
   
7. #define JDQ_L
   
8. long int in_code[7];
   
9. int in_code_i=0;
   
10. long int in_l_code[6];
    
11. int in_l_code_i=0;
    
12. uint16_t val[13];
    
13. uint16_t r_val[13];
    
14. unsigned char s_date[30];
    
15. unsigned char r_date[30];
    
16. char flag=0;//0时接收中断，采集数据；1时接收完成，发送数据。
    
17. char T_flag=0,bit_flag=0,bit_flag1=0;
    
18. long int h_now,l_now;
    
19. int chk_count,bit_count;
    
20. int buzer=3;
    
21. char buzer_flag=0;
    
22. int buzer_i,buzer_count;
    
23. #ifdef JDQ_L
    
24. #define ON 0
    
25. #define OFF 1
    
26. #endif
    
27. 
    
28. #ifdef JDQ_H
    
29. #define ON 1
    
30. #define OFF 0
    
31. #endif
    
32. uint16_t mos_code=0x0000;
    
33. uint16_t r_mos_code=0x0000;
    
34. String s_b="";
    
35. String r_b="";
    
36. char mode_flag=0;
    
37. char r_flag=0;
    
38. int r_d_i=0,r_d_h=3,r_d_v=2,s_d_i=0,s_d_h=3,s_d_v=0;
    
39. char date_flag=0;
    
40. 
    
41. char kg_flag=0,s_qp_flag=0;
    
42. int kg_count;
    
43. 
    
44. int by_v_code[13];
    
45. int by_v_i=0;
    
46. int by_y_l=0;
    
47. int by_y_i=0;
    
48. int by_count,by_d_count;
    
49. char by_d_flag=0;
    
50. char by_tr_flag=0;//0时编码未转换，不能发声；1时转换完成，可以发声
    
51. uint16_t by_code[]={0x07ff,0x000d,0x0057,0x0077,0x0017,0x0001,0x0075,0x001f,0x0055,0x0005,0x00fd,0x0037,0x005d,0x000f,0x0007,0x003f,0x007d,
    
52.                  0x00df,0x001d,0x0015,0x0003,0x0035,0x00d5,0x003d,0x00d7,0x00f7,0x005f,0x03fd,0x03f5,0x03d5,0x0355,0x0155,
    
53.                  0x0157,0x015f,0x017f,0x01ff,0x03ff};//36
    
54. String by_a="";
    
55. char by_flag=0;
    
56. char ch_flag=0;
    
57. void by_code_trans()
    
58. {
    
59.   if(by_flag==1)
    
60.   {
    
61.   if(by_tr_flag==0)
    
62.   {
    
63.     for(int i=0;i<13;i++)
    
64.     {
    
65.       by_v_code[i]=0;
    
66.       }
    
67.     char temp;
    
68.     for(int i=0;i<7;i++)
    
69.     {
    
70.       temp=0x00;
    
71.       temp|=(by_code[by_v_i]>>(i*2))&0x0003;
    
72.       if(temp==0x00)
    
73.       {
    
74.         by_v_code[2*i]=0;
    
75.         }
    
76.         if(temp==0x01)
    
77.         {
    
78.           by_v_code[2*i]=66;
    
79.         
    
80.           }
    
81.           if(temp==0x03)
    
82.         {
    
83.           by_v_code[2*i]=297;
    
84.          
    
85.           }
    
86.           if(i<6)
    
87.           {
    
88.          by_v_code[2*i+1]=100;
    
89.           }
    
90.       }
    
91. 
    
92.      by_tr_flag=1;  
    
93.      digitalWrite(buzer,ON);
    
94.     }
    
95.   }
    
96.   
    
97.   }
    
98. String by_code_transs(uint16_t code)
    
99. {
    
100.   String b="";
     
101. 
     
102. 
     
103.     switch(code)
     
104.       {
     
105.         case 0x000d:b="A";break;
     
106.         case 0x0057:b="B";break;
     
107.         case 0x0077:b="C";break;
     
108.         case 0x0017:b="D";break;
     
109.         case 0x0001:b="E";break;
     
110.         case 0x0075:b="F";break;
     
111.         case 0x001f:b="G";break;
     
112.         case 0x0055:b="H";break;
     
113.         case 0x0005:b="I";break;
     
114.         case 0x00fd:b="J";break;
     
115.         case 0x0037:b="K";break;
     
116.         case 0x005d:b="L";break;
     
117.         case 0x000f:b="M";break;
     
118.         case 0x0007:b="N";break;
     
119.         case 0x003f:b="O";break;
     
120.         case 0x007d:b="P";break;
     
121.         case 0x00df:b="Q";break;
     
122.         case 0x001d:b="R";break;
     
123.         case 0x0015:b="S";break;
     
124.         case 0x0003:b="T";break;
     
125.         case 0x0035:b="U";break;
     
126.         case 0x00d5:b="V";break;
     
127.         case 0x003d:b="W";break;
     
128.         case 0x00d7:b="X";break;
     
129.         case 0x00f7:b="Y";break;
     
130.         case 0x005f:b="Z";break;
     
131.         case 0x03fd:b="1";break;
     
132.         case 0x03f5:b="2";break;
     
133.         case 0x03d5:b="3";break;
     
134.         case 0x0355:b="4";break;
     
135.         case 0x0155:b="5";break;
     
136.         case 0x0157:b="6";break;
     
137.         case 0x015f:b="7";break;
     
138.         case 0x017f:b="8";break;
     
139.         case 0x01ff:b="9";break;
     
140.         case 0x03ff:b="0";break;
     
141.         case 0x05f5:b="?";break;
     
142.         case 0x057f:b=":";break;
     
143.         case 0x01d7:b="/";break;
     
144.         case 0x0d57:b="-";break;
     
145.         case 0x0ddd:b=".";break;
     
146.         case 0x0f5f:b=",";break;
     
147.         case 0x077d:b="@";break;
     
148.         case 0x0357:b="=";break;
     
149.         case 0x07fd:b="'";break;
     
150.         case 0x07f5:b="!";break;
     
151.         case 0x0777:b=";";break;
     
152.         case 0x01f7:b="(";break;
     
153.         case 0x0df7:b=")";break;
     
154.         case 0x01dd:b="+";break;
     
155.         case 0x015d:b="&";break;
     
156.         case 0x0df5:b="_";break;
     
157.         case 0x075d:b="''";break;
     
158.         case 0x35d5:b="$";break;
     
159.         case 0x07ff:b=">";break;
     
160.         default:b="*";
     
161.       }
     
162.    
     
163. 
     
164.     return b;
     
165.   }
     
166. 
     
167. 
     
168. void by()
     
169. {
     
170.   if(by_tr_flag==1&&by_d_flag==0)
     
171.   {
     
172.     by_count+=1;
     
173.     if(by_count>by_v_code[by_y_i])
     
174.     {
     
175.       by_count=0;
     
176.      
     
177.       by_y_i+=1;
     
178.       if((by_v_code[by_y_i]==0&&by_y_i%2==0)||(by_y_i+2)%2!=0)
     
179.       {
     
180.        digitalWrite(buzer,OFF);
     
181.         }
     
182.         else
     
183.         {
     
184.           digitalWrite(buzer,!digitalRead(buzer));
     
185.         }
     
186.       if(by_y_i>12)
     
187.       {
     
188.         by_y_i=0;
     
189.         digitalWrite(buzer,OFF);
     
190.         
     
191.       by_d_flag=1;
     
192.        by_a=by_code_transs(by_code[by_v_i]);
     
193.        r_d_i+=1;
     
194.        if(r_d_i<18)
     
195.       {
     
196.         r_d_h=r_d_i+2;
     
197.         r_d_v=2;
     
198.         }
     
199.        if(r_d_i>17&&r_d_i<38)
     
200.        {
     
201.         r_d_h=r_d_i-18;
     
202.         r_d_v=3;
     
203.         }
     
204.         if(r_d_i>37)
     
205.         {
     
206.           r_d_i=1;
     
207.           r_d_h=3;
     
208.           r_d_v=2;
     
209.         //lcd.setCursor(3,2);
     
210.          //lcd.print(r_b);
     
211.           lcd.setCursor(3,2);
     
212.          lcd.print("                 ");
     
213.           lcd.setCursor(0,3);
     
214.          lcd.print("                    ");
     
215.           }
     
216.       lcd.setCursor(r_d_h,r_d_v);
     
217.       lcd.print(by_a);
     
218.            
     
219.         }
     
220.       
     
221.       }
     
222. 
     
223.     }
     
224.     if(by_tr_flag==1&&by_d_flag==1)
     
225.     {
     
226.       by_d_count+=1;
     
227.       if(by_d_count>535)
     
228.       {
     
229.         by_d_count=0;
     
230.         by_tr_flag=0;
     
231.         by_d_flag=0;
     
232.          by_v_i+=1;
     
233.             if(by_v_i>36)
     
234.             {
     
235.               ch_flag=1;
     
236.               by_v_i=0;
     
237.               by_flag=0;
     
238.                  lcd.setCursor(3,2);
     
239.                   lcd.print("                 ");
     
240.                   
     
241.                    lcd.setCursor(0,3);
     
242.                       lcd.print("                    ");
     
243.                        r_d_i=0;
     
244.                        r_d_h=2;
     
245.                        r_d_v=2;
     
246.               }
     
247.         }
     
248.       }
     
249.   }
     
250. 
     
251. 
     
252. void s_wz()
     
253. {
     
254.          bit_flag=0;
     
255.         in_code_i=0;
     
256.         in_l_code_i=0;
     
257.         //chk_count=0;
     
258.         T_flag=0;
     
259.         flag=1;
     
260.         s_date[29]|=0x01;
     
261.       s_d_i+=1;
     
262.       if(s_d_i<18)
     
263.       {
     
264.         s_d_h=s_d_i+2;
     
265.         s_d_v=0;
     
266.         }
     
267.        if(s_d_i>17&&s_d_i<38)
     
268.        {
     
269.         s_d_h=s_d_i-18;
     
270.         s_d_v=1;
     
271.         }
     
272.          if(s_d_i>37)
     
273.         {
     
274.           s_qp_flag=1;
     
275.           s_d_i=1;
     
276.           s_d_h=3;
     
277.           s_d_v=0;
     
278.           }
     
279.   }
     
280. void flash()
     
281. {
     
282. if(by_flag==0)
     
283. {
     
284.   if(flag==0)
     
285.   {
     
286.     if(digitalRead(2)==1)
     
287.     {
     
288. 
     
289.       buzer_flag=0;
     
290.       buzer_count=0;
     
291.       buzer_i=0;
     
292.       bit_flag=0;
     
293.       bit_count=0;
     
294.       kg_count=0;
     
295.       kg_flag=0;
     
296.      digitalWrite(buzer,ON);
     
297.      delayMicroseconds(100);
     
298.      if(digitalRead(2)==1)
     
299.      {
     
300.       h_now=micros();
     
301.       if(in_code_i>0&&in_code_i<6)
     
302.       {
     
303.         in_l_code[in_l_code_i]=h_now-l_now;
     
304.         in_l_code_i+=1;
     
305.            if(in_l_code_i>5)
     
306.             {
     
307.               in_l_code_i=0;
     
308.              }
     
309.         }
     
310.       if(T_flag==0)
     
311.       {
     
312.         T_flag=1;
     
313.         }
     
314.        }
     
315.       }
     
316.     if(digitalRead(2)==0)
     
317.     {
     
318.       delayMicroseconds(100);
     
319.       digitalWrite(buzer,OFF);
     
320.       if(digitalRead(2)==0)
     
321.       {
     
322.       l_now=micros();
     
323.       in_code[in_code_i]= l_now-h_now;
     
324.       in_code_i+=1;
     
325.       bit_flag=1;
     
326.       if(in_code_i>6)
     
327.       {
     
328.         s_wz();
     
329.        // bit_flag=0;
     
330.        // bit_count=0;
     
331.         //in_code_i=0;
     
332.         //bit_flag1=1;
     
333.         //flag=1;
     
334.         //T_flag=0;
     
335.          //s_d_i+=1;
     
336.          //kg_flag=1;
     
337.         //chk_count=0;
     
338.         }
     
339.     }
     
340.       }
     
341.     }
     
342.    }
     
343.   }
     
344. void input_chk()
     
345. {
     
346.   if(by_flag==0)
     
347.   {
     
348.   if(flag==0&&buzer_flag==0)
     
349.   {
     
350.     if(digitalRead(2)==0)
     
351.     {
     
352.       digitalWrite(buzer,OFF);
     
353.       }
     
354.     }
     
355.     if(kg_flag==1)
     
356.   {
     
357.     kg_count+=1;
     
358.     if(kg_count>200)
     
359.     {
     
360.       kg_count=0;
     
361.       kg_flag=0;
     
362.       s_d_i+=1;
     
363.       s_date[29]|=0x02;
     
364.       }
     
365.     }
     
366. /* if(T_flag==1)
     
367.   {
     
368.     chk_count+=1;
     
369.     if(chk_count>4000)
     
370.     {
     
371.       in_code_i=0;
     
372.       in_l_code_i=0;
     
373.       chk_count=0;
     
374.       T_flag=0;
     
375.       flag=1;
     
376.       }
     
377.     }*/
     
378.     if(bit_flag==1)
     
379.     {
     
380.       bit_count+=1;
     
381.      
     
382.       if(bit_count>150)
     
383.       {
     
384.         
     
385.         bit_count=0;
     
386.         s_wz();
     
387.         }
     
388.      
     
389.       }
     
390. 
     
391.   if(buzer_flag==1)
     
392.   {
     
393.     buzer_count+=1;
     
394.     if(buzer_count>r_val[buzer_i])
     
395.     {
     
396.       buzer_count=0;
     
397.       buzer_i+=1;
     
398.        if((r_val[buzer_i]==0&&buzer_i%2==0)||(buzer_i+2)%2!=0)
     
399.       {
     
400.        digitalWrite(buzer,OFF);
     
401.         }
     
402.         else
     
403.         {
     
404.           digitalWrite(buzer,!digitalRead(buzer));
     
405.         }
     
406.       if(buzer_i>12)
     
407.       {
     
408.         buzer_i=0;
     
409.         buzer_flag=0;
     
410.         digitalWrite(buzer,OFF);
     
411.        for(int i=0;i<13;i++)
     
412.       {
     
413.         r_val[i]=0;
     
414.         }
     
415.         }
     
416.       }
     
417.     }
     
418.   }
     
419.   if(by_flag==1)
     
420.   {
     
421.     by();
     
422.     }
     
423.   }
     
424. String code_trans(uint16_t code,char mode)
     
425. {
     
426.   String b="";
     
427. 
     
428.   if(mode==0)
     
429.   {
     
430.     switch(code)
     
431.       {
     
432.         case 0x000d:b="A";break;
     
433.         case 0x0057:b="B";break;
     
434.         case 0x0077:b="C";break;
     
435.         case 0x0017:b="D";break;
     
436.         case 0x0001:b="E";break;
     
437.         case 0x0075:b="F";break;
     
438.         case 0x001f:b="G";break;
     
439.         case 0x0055:b="H";break;
     
440.         case 0x0005:b="I";break;
     
441.         case 0x00fd:b="J";break;
     
442.         case 0x0037:b="K";break;
     
443.         case 0x005d:b="L";break;
     
444.         case 0x000f:b="M";break;
     
445.         case 0x0007:b="N";break;
     
446.         case 0x003f:b="O";break;
     
447.         case 0x007d:b="P";break;
     
448.         case 0x00df:b="Q";break;
     
449.         case 0x001d:b="R";break;
     
450.         case 0x0015:b="S";break;
     
451.         case 0x0003:b="T";break;
     
452.         case 0x0035:b="U";break;
     
453.         case 0x00d5:b="V";break;
     
454.         case 0x003d:b="W";break;
     
455.         case 0x00d7:b="X";break;
     
456.         case 0x00f7:b="Y";break;
     
457.         case 0x005f:b="Z";break;
     
458.         case 0x03fd:b="1";break;
     
459.         case 0x03f5:b="2";break;
     
460.         case 0x03d5:b="3";break;
     
461.         case 0x0355:b="4";break;
     
462.         case 0x0155:b="5";break;
     
463.         case 0x0157:b="6";break;
     
464.         case 0x015f:b="7";break;
     
465.         case 0x017f:b="8";break;
     
466.         case 0x01ff:b="9";break;
     
467.         case 0x03ff:b="0";break;
     
468.         case 0x05f5:b="?";break;
     
469.         case 0x057f:b=":";break;
     
470.         case 0x01d7:b="/";break;
     
471.         case 0x0d57:b="-";break;
     
472.         case 0x0ddd:b=".";break;
     
473.         case 0x0f5f:b=",";break;
     
474.         case 0x077d:b="@";break;
     
475.         case 0x0357:b="=";break;
     
476.         case 0x07fd:b="'";break;
     
477.         case 0x07f5:b="!";break;
     
478.         case 0x0777:b=";";break;
     
479.         case 0x01f7:b="(";break;
     
480.         case 0x0df7:b=")";break;
     
481.         case 0x01dd:b="+";break;
     
482.         case 0x015d:b="&";break;
     
483.         case 0x0df5:b="_";break;
     
484.         case 0x075d:b="''";break;
     
485.         case 0x35d5:b="$";break;
     
486.         case 0x15ff:
     
487.                       b="s";
     
488.                       mode_flag=1;  
     
489.                       lcd.setCursor(1,0);
     
490.                       lcd.print(b);
     
491.                       lcd.setCursor(1,2);
     
492.                       lcd.print(b);break;
     
493.          case 0x07ff: by_flag=1;
     
494.                       b=">";
     
495.                      
     
496.                       lcd.setCursor(3,2);
     
497.                       lcd.print("                 ");
     
498.                       lcd.setCursor(0,3);
     
499.                       lcd.print("                    ");
     
500.                        r_d_i=0;
     
501.                        r_d_h=3;
     
502.                        r_d_v=2;
     
503.                       break;
     
504.         default:b="*";
     
505.         }
     
506.     }
     
507.     if(mode==1)
     
508.     {
     
509.       switch(code)
     
510.       {
     
511.         case 0x000d:b="1";break;
     
512.         case 0x0035:b="2";break;
     
513.         case 0x03d5:b="3";break;
     
514.         case 0x0355:b="4";break;
     
515.         case 0x0155:b="5";break;
     
516.         case 0x0157:b="6";break;
     
517.         case 0x015f:b="7";break;
     
518.         case 0x0017:b="8";break;
     
519.         case 0x0007:b="9";break;
     
520.         case 0x0003:b="0";break;
     
521.         case 0x03ff:
     
522.                  b="l";
     
523.                  mode_flag=0;
     
524.                  lcd.setCursor(1,0);
     
525.                  lcd.print(b);
     
526.                  lcd.setCursor(1,2);
     
527.                  lcd.print(b);
     
528.                
     
529.                  break;
     
530.         default:b="*";
     
531.         }
     
532.       }
     
533.     return b;
     
534.   }
     
535. void date_display()
     
536. {
     
537. 
     
538.   if(flag==1)
     
539.   {
     
540.     mos_code=0x0000;
     
541.     for(int i=0;i<7;i++)
     
542.     {
     
543.    
     
544.      
     
545.       if(in_code[i]>50&&in_code[i]<120000)
     
546.       {
     
547.         mos_code|=0x0001<<(2*i);
     
548.         }
     
549.        if(in_code[i]>120000&&in_code[i]<450000)
     
550.        {
     
551.          mos_code|=0x0001<<(2*i);
     
552.          mos_code|=0x0002<<(2*i);
     
553.         }
     
554.       
     
555. 
     
556.       }
     
557.     s_b=code_trans(mos_code,mode_flag);
     
558.   
     
559.       val[0]=in_code[0]/1000;
     
560.       val[2]=in_code[1]/1000;
     
561.       val[4]=in_code[2]/1000;
     
562.       val[6]=in_code[3]/1000;
     
563.       val[8]=in_code[4]/1000;
     
564.       val[10]=in_code[5]/1000;
     
565.       val[12]=in_code[6]/1000;
     
566.   
     
567.       val[1]=in_l_code[0]/1000;
     
568.       val[3]=in_l_code[1]/1000;
     
569.       val[5]=in_l_code[2]/1000;
     
570.       val[7]=in_l_code[3]/1000;
     
571.       val[9]=in_l_code[4]/1000;
     
572.       val[11]=in_l_code[5]/1000;
     
573.       
     
574.       
     
575.      s_date[0]=0xf0;
     
576.    
     
577.       for(int i=0;i<13;i++)
     
578.       {
     
579.         s_date[(2*i)+1]=val[i]&0x007f;
     
580.         s_date[(2*i)+2]=(val[i]&0xff80)>>7;
     
581.         if(i<7)
     
582.         {
     
583.          in_code[i]=0;
     
584.         }
     
585.         }
     
586.        s_date[27]=mos_code&0x007f;
     
587.        s_date[28]=(mos_code&0xff80)>>7;
     
588.        if(by_flag==0)
     
589.        {
     
590.        for(int i=0;i<30;i++)
     
591.        {
     
592.          Serial.write(s_date[i]);
     
593.          s_date[i]=0;
     
594.          if(i<6)
     
595.          {in_l_code[i]=0;}
     
596.           if(i<7)
     
597.          {in_code[i]=0;}
     
598.          if(i<13)
     
599.          {val[i]=0;}
     
600.         }
     
601.        }
     
602.       lcd.setCursor(s_d_h,s_d_v);
     
603.       lcd.print(s_b);
     
604. 
     
605. 
     
606.         if(s_qp_flag==1)
     
607.         {
     
608.           lcd.setCursor(4,0);
     
609.           lcd.print("                ");
     
610.           lcd.setCursor(0,1);
     
611.           lcd.print("                    ");
     
612.           s_qp_flag=0;
     
613.           }
     
614.       kg_flag=1;
     
615.       s_date[29]=0x00;
     
616.       flag=0;
     
617.     }
     
618.    if(by_flag==0)
     
619.    {
     
620.     if(r_flag==1)
     
621.     {
     
622.       r_b=code_trans(r_mos_code,mode_flag);
     
623.    
     
624.       if(r_date[29]==0x01)
     
625.       {
     
626.         r_d_i+=1;
     
627.         }
     
628.        if(r_date[29]==0x03)
     
629.        {
     
630.         if(ch_flag==0)
     
631.         {
     
632.           r_d_i+=2;
     
633.           }
     
634.         if(ch_flag==1)
     
635.         {
     
636.           r_d_i+=1;
     
637.           ch_flag=0;
     
638.           }
     
639.          
     
640.         
     
641.         }
     
642.      
     
643.       
     
644.       if(r_d_i<18)
     
645.       {
     
646.         r_d_h=r_d_i+2;
     
647.         r_d_v=2;
     
648.         }
     
649.        if(r_d_i>17&&r_d_i<38)
     
650.        {
     
651.         r_d_h=r_d_i-18;
     
652.         r_d_v=3;
     
653.         }
     
654.         if(r_d_i>37)
     
655.         {
     
656.           r_d_i=1;
     
657.           r_d_h=3;
     
658.           r_d_v=2;
     
659.         //lcd.setCursor(3,2);
     
660.          //lcd.print(r_b);
     
661.           lcd.setCursor(4,2);
     
662.          lcd.print("                ");
     
663.           lcd.setCursor(0,3);
     
664.          lcd.print("                    ");
     
665.           }
     
666.       lcd.setCursor(r_d_h,r_d_v);
     
667.       lcd.print(r_b);
     
668.       if(T_flag==0)
     
669.       {
     
670.         buzer_flag=1;
     
671.         digitalWrite(buzer,ON);
     
672.         }
     
673.        r_mos_code=0x0000;
     
674.       r_flag=0;  
     
675.       }
     
676.    }
     
677.       
     
678.   }
     
679. void serialEvent()
     
680. {
     
681. if(by_flag==0)
     
682. {
     
683.   if(Serial.available()>29)
     
684.   {
     
685. 
     
686.     while(date_flag==0)
     
687.     {
     
688.       r_date[0]=Serial.read();
     
689.       if(r_date[0]==0xf0)
     
690.       {
     
691.         date_flag=1;
     
692.         }
     
693.       }
     
694.      if(date_flag==1)
     
695.      {
     
696.       
     
697.      
     
698.       for(int i=1;i<30;i++)
     
699.       {
     
700.          r_date[i]=Serial.read();
     
701.         }
     
702.        r_val[0]=(r_date[1]&0x007f)|((r_date[2]<<7)&0xff80);
     
703.        r_val[1]=(r_date[3]&0x007f)|((r_date[4]<<7)&0xff80);
     
704.        r_val[2]=(r_date[5]&0x007f)|((r_date[6]<<7)&0xff80);
     
705.        r_val[3]=(r_date[7]&0x007f)|((r_date[8]<<7)&0xff80);
     
706.        r_val[4]=(r_date[9]&0x007f)|((r_date[10]<<7)&0xff80);
     
707.        r_val[5]=(r_date[11]&0x007f)|((r_date[12]<<7)&0xff80);
     
708.        r_val[6]=(r_date[13]&0x007f)|((r_date[14]<<7)&0xff80);
     
709.        r_val[7]=(r_date[15]&0x007f)|((r_date[16]<<7)&0xff80);
     
710.        r_val[8]=(r_date[17]&0x007f)|((r_date[18]<<7)&0xff80);
     
711.        r_val[9]=(r_date[19]&0x007f)|((r_date[20]<<7)&0xff80);
     
712.        r_val[10]=(r_date[21]&0x007f)|((r_date[22]<<7)&0xff80);
     
713.        r_val[11]=(r_date[23]&0x007f)|((r_date[24]<<7)&0xff80);
     
714.        r_val[12]=(r_date[25]&0x007f)|((r_date[26]<<7)&0xff80);
     
715.       
     
716.       r_mos_code=(r_date[27]&0x007f)|((r_date[28]<<7)&0xff80);
     
717.       
     
718.          r_flag=1;
     
719.          date_flag=0;
     
720.       }
     
721.     }
     
722.   }
     
723.   if(by_flag==1)
     
724.   {
     
725.     if(Serial.available()>0)
     
726.     {
     
727.       char n;
     
728.       while(Serial.available()>0)
     
729.       {
     
730.         n=Serial.read();
     
731.         }
     
732.       }
     
733.     }
     
734.   }
     
735. void setup() {
     
736.   lcd.init();                     
     
737.   lcd.init();
     
738.   lcd.backlight();
     
739.   
     
740. Serial.begin(115200);
     
741. pinMode(buzer,OUTPUT);
     
742. digitalWrite(buzer,OFF);
     
743. pinMode(2,INPUT);
     
744. attachInterrupt(0,flash,CHANGE);
     
745. lcd.setCursor(1,0);
     
746. lcd.print("Morse code trainer");
     
747. lcd.setCursor(2,1);
     
748. lcd.print("Software version");
     
749. lcd.setCursor(7,2);
     
750. lcd.print("V1.1.0");
     
751. delay(2000);
     
752. lcd.clear();
     
753. lcd.setCursor(0,0);
     
754. lcd.print("Tl:");
     
755. lcd.setCursor(0,2);
     
756. lcd.print("Rl:");
     
757. t.every(1,input_chk);
     
758. t.every(10,by_code_trans);
     
759. t.every(40,date_display);
     
760. }
     
761. 
     
762. void loop() {
     
763.   t.update();
     
764. }

复制代码

顾什三

大哥你是神仙吗！！