sim900a读取短信之后TCP通信就无法进行。。

毛驴

我想请教一个问题，我用arduino mega 2560连sim900a实现了两个功能，一个是读短信条数，读取短信，删除短信，第二个是TCP连接，两个功能单独实现能成功，但是合在一起TCP就无法连接，请问这是怎么回事。

1. #include <Narcoleptic.h>
   
2. #include <EEPROM.h>
   
3. #include <SPI.h>
   
4. #include <stdlib.h>
   
5. int dustPin = 0;                                        //从A0读扬尘值
   
6. int ledPower = 2;                                      //扬尘传感器的LED灯开关接引脚2
   
7. int pmof = 3;                                         //控制扬尘传感器的开关是3号引脚
   
8. int noiseof = 4;                                     //控制噪声传感器的开关是4号引脚
   
9. int simof = 5;                                       //控制sim900a的开关是5号引脚
   
10. int duanxinnum = 0;                                    //短信的条数
    
11. int sleeptime = 0, noisenum = 0;                      //睡眠时间和噪音测量时间
    
12. String ip = "";                                     //TCP连接时发送用的
    
13. String port = "";                                   //TCP连接时发送用的
    
14. String iphex = "";                                  //存放ip的8个十六进制字符
    
15. int ipdec[4] = {0};                                //ip四段的十进制数字
    
16. int porteeprom1 = 0, porteeprom2 = 0 ;              //两字节的端口号
    
17. unsigned char noise = 0;                          //噪声值
    
18. int pm = 0;                                       //扬尘值，在0到500之间
    
19. unsigned char pmh = 0, pml = 0;                    //扬尘高位值和低位的值
    
20. unsigned char datasend[11] = {0};                 //要发送的11个字节的数组
    
21. unsigned char datarece[60] = {0};                 //接收数据的数组
    
22. void setup() {
    
23.   Serial.begin(9600);
    
24.   Serial2.begin(2400);
    
25.   Serial3.begin(9600);
    
26.   pinMode(ledPower, OUTPUT);                  //2号引脚设为输出
    
27.   pinMode(pmof, OUTPUT);                  //3号引脚设为输出
    
28.   pinMode(noiseof, OUTPUT);                  //4号引脚设为输出
    
29.   pinMode(simof, OUTPUT);                  //5号引脚设为输出
    
30. }
    
31. 
    
32. void loop() {
    
33.   chushihua();
    
34. //  chulismsip();
    
35.   while(1)
    
36.   {
    
37.   digitalWrite(simof, HIGH);              //打开sim900a
    
38.   digitalWrite(pmof, HIGH);
    
39.   delay(18000);
    
40.   pm = getpmnum();
    
41.   pml = pm % 256;                          //低位的pm值
    
42.   pmh = (pm - pml) / 256;                 //高位的pm值
    
43.   digitalWrite(pmof, LOW);
    
44.   //   noise = maxnoise(EEPROM.read(7));                  //得到噪声值
    
45.   noise = 62;
    
46.   duanxinnum = SMSnum();
    
47.   if ((duanxinnum > 0) && (duanxinnum < 10))
    
48.   {
    
49.     chuliduanxin(duanxinnum);
    
50.     xierueeprom();
    
51.   }
    
52.   delallsms();
    
53.    package();
    
54.   tcplink();
    
55.   digitalWrite(simof, LOW);              //关闭sim900a
    
56.   delay(2000);
    
57.   sleepmode(EEPROM.read(6));
    
58.   }
    
59. //  Serial.println(EEPROM.read(8));
    
60. //  Serial.println(EEPROM.read(9));
    
61. //  Serial.println(EEPROM.read(10));
    
62. // Serial.println(EEPROM.read(11));
    
63. // Serial.println(EEPROM.read(12));
    
64. // Serial.println();
    
65.   //  Serial.println(sleeptime);
    
66.   //  Serial.println(noisenum);
    
67.   //  Serial.println(ip);
    
68.   // Serial.println(port);
    
69.   // Serial.print(iphex);
    
70. //  Serial.println(pm);
    
71. // Serial.println(pmh);
    
72. //  Serial.println(pml);
    
73.   delay(5000);
    
74. 
    
75. }
    
76. 
    
77. 
    
78. int SMSnum()                              //get the num of sms
    
79. {
    
80.   String datasim = "";
    
81.   int i = 0, mark = 0, num = 0;
    
82.   Serial3.print("AT+CPMS=");
    
83.   Serial3.print('"');
    
84.   Serial3.print("SM");
    
85.   Serial3.print('"');
    
86.   Serial3.print("\r\n");
    
87.   delay(1000);
    
88.   while (Serial3.available() > 0)
    
89.   {
    
90.     //读入之后将字符串，串接到comdata上面。
    
91.     datasim += char(Serial3.read());
    
92.     //延时一会，让串口缓存准备好下一个数字，不延时会导致数据丢失，
    
93.     delay(2);
    
94.     //标记串口读过数据，如果没有数据的话，直接不执行这个while了。
    
95.     mark = 1;
    
96.   }
    
97.   if (mark == 1)
    
98.     // {
    
99.     //  Serial.println(datasim.length());
    
100.     // for (i = 0; i < datasim.length(); i++)
     
101.     // {
     
102.     //    Serial.print(datasim[i]);
     
103.     //    delay(100);
     
104.     //  }
     
105.     // Serial.print(datasim[23]);
     
106.     num = int(datasim[23]) - 48;
     
107.   // Serial.print(num);
     
108.   //  datasim = "";
     
109.   //  delay(1000);
     
110.   //  mark = 0;
     
111.   //   }
     
112.   return num;
     
113. }
     
114. 
     
115. 
     
116. void  chuliduanxin(int n)    //fen 9 tiao du duan xin
     
117. {
     
118.   int i = 1;
     
119.   //  Serial.println(n);
     
120.   for (i = 1; i <= n; i++)
     
121.   {
     
122.     switch (i)
     
123.     {
     
124.       case 1:
     
125.         {
     
126.           Serial3.print("AT+CMGR=1\r\n");
     
127.           chulisms();
     
128.           break;
     
129.         }
     
130.       case 2:
     
131.         {
     
132.           Serial3.print("AT+CMGR=2\r\n");
     
133.           chulisms();
     
134.           break;
     
135.         }
     
136.       case 3:
     
137.         {
     
138.           Serial3.print("AT+CMGR=3\r\n");
     
139.           chulisms();
     
140.           break;
     
141.         }
     
142.       case 4:
     
143.         {
     
144.           Serial3.print("AT+CMGR=4\r\n");
     
145.           chulisms();
     
146.           break;
     
147.         }
     
148.       case 5:
     
149.         {
     
150.           Serial3.print("AT+CMGR=5\r\n");
     
151.           chulisms();
     
152.           break;
     
153.         }
     
154.       case 6:
     
155.         {
     
156.           Serial3.print("AT+CMGR=6\r\n");
     
157.           chulisms();
     
158.           break;
     
159.         }
     
160.       case 7:
     
161.         {
     
162.           Serial3.print("AT+CMGR=7\r\n");
     
163.           chulisms();
     
164.           break;
     
165.         }
     
166.       case 8:
     
167.         {
     
168.           Serial3.print("AT+CMGR=8\r\n");
     
169.           chulisms();
     
170.           break;
     
171.         }
     
172.       case 9:
     
173.         {
     
174.           Serial3.print("AT+CMGR=9\r\n");
     
175.           chulisms();
     
176.           break;
     
177.         }
     
178.     }
     
179.   }
     
180. }
     
181. 
     
182. void chulisms()           //get sms and deal with it
     
183. {
     
184.   int a = 0, mark = 0, i = 0, douhaonum = 0, j = 0, k = 0, p = 0, first = 0, second = 0;
     
185.   int b = 0, m = 0, n = 0;
     
186.   unsigned long telnum = 0 ;                              //电话号码后9位的十进制数
     
187.   unsigned long time0 = 0, time1 = 0;                    //记录程序运行的时间差，超过就退出
     
188.   unsigned long int tempip = 0;                                 //字符型转化为长整型ip的值
     
189.   long int tempport = 0;                                     //字符型转化为长整型Port的值
     
190.   int douhao[4] = {0};                                   //逗号出现的位置
     
191.   String datasim = "";
     
192.   char datafirst[25];                                 //第二个和第三个逗号之间
     
193.   char datasecond[25];                              //第三个和第四个逗号之间
     
194.   int datajia1[5] = {0};                                //电话号码的前两位的五位八进制
     
195.   int datajia2[5] = {0};                                //电话号码的后9位的五位八进制
     
196.   int datajia3[5] = {0};                                //电话号码的进位的五位八进制
     
197.   for (a = 0 ; a < 2; a++)
     
198.   {
     
199.     time0 = millis();
     
200.     while (!Serial3.available())                    //wait until data appear
     
201.     {
     
202.       time1 = millis();
     
203.       if ((time1 - time0) > 2000)                   //两秒还没有就退出等待
     
204.         break;
     
205.     }
     
206.     while (Serial3.available() > 0)
     
207.     {
     
208. 
     
209.       datasim += char(Serial3.read());
     
210.       //延时一会，让串口缓存准备好下一个数字，不延时会导致数据丢失，
     
211.       delay(2);
     
212.       //标记串口读过数据，如果没有数据的话，直接不执行这个while了。
     
213.       mark = 1;
     
214.     }
     
215.   }
     
216. 
     
217.   if (mark == 1)            // deal with sms
     
218.   {
     
219.    // Serial.println(datasim.length());
     
220.     //for (i = 0; i < datasim.length(); i++)
     
221.    // {
     
222.      // Serial.print(datasim[i]);
     
223.      // delay(30);
     
224.   //  }
     
225.     for (i = 0; i < (datasim.length()); i++)
     
226.     {
     
227.       if (datasim[i] == 'Z')
     
228.         if (datasim[i + 1] == 'N')
     
229.           if (datasim[i + 2] == 'G')
     
230.             if (datasim[i + 3] == 'Y')        //add a if jiaoyan
     
231.             {
     
232.               if (datasim[i + 5] == '2')
     
233.               {
     
234.                 for (j = i; j < i + 28; j++)       //标记逗号在datasim里的位置
     
235.                 {
     
236.                   if (datasim[j] == ',')
     
237.                   {
     
238.                     douhao[douhaonum] = j;
     
239.                     douhaonum++;
     
240.                   }
     
241.                 }
     
242.                 for (k = douhao[1] + 1; k < douhao[2]; k++) //逗号2和逗号3之间的赋给datafirst
     
243.                 {
     
244.                   datafirst[first] = datasim[k];
     
245.                   first++;
     
246.                 }
     
247.                 datafirst[first] = '\0';
     
248.                 for (p = douhao[2] + 1; p < douhao[3]; p++) //逗号3和逗号4之间的赋给datasecond
     
249.                 {
     
250.                   datasecond[second] = datasim[p];
     
251.                   second++;
     
252.                 }
     
253.                 datasecond[second] = '\0';
     
254.                 tempip = atol(datafirst);
     
255.                 tempport = atol(datasecond);
     
256.                 PrintHex(tempip);
     
257.                 ipdec[0] = hextodec(iphex[0], iphex[1]);            //将ip从十六进制转化为4段十进制数
     
258.                 ipdec[1] = hextodec(iphex[2], iphex[3]);
     
259.                 ipdec[2] = hextodec(iphex[4], iphex[5]);
     
260.                 ipdec[3] = hextodec(iphex[6], iphex[7]);
     
261.                 dectostring(ipdec[0], ipdec[1], ipdec[2], ipdec[3]);    //将十进制数转化成ip字符串
     
262.                 port = "";
     
263.                 for (b = 0; b < 8; b++)
     
264.                 {
     
265.                   if (datasecond[b] == '\0')
     
266.                     break;
     
267.                   port += datasecond[b];
     
268.                 }
     
269.                 porteeprom2 = tempport % 256;
     
270.                 porteeprom1 = (tempport - porteeprom2) / 256;
     
271. 
     
272. 
     
273.                 Serial.println(tempip);
     
274.                 Serial.println(tempport);
     
275. 
     
276.               }
     
277.               if (datasim[i + 5] == '3')
     
278.               {
     
279.                 for (j = i; j < i + 20; j++)       //标记逗号在datasim里的位置
     
280.                 {
     
281.                   if (datasim[j] == ',')
     
282.                   {
     
283.                     douhao[douhaonum] = j;
     
284.                     douhaonum++;
     
285.                   }
     
286.                 }
     
287.                 for (k = douhao[1] + 1; k < douhao[2]; k++) //逗号2和逗号3之间的赋给datafirst
     
288.                 {
     
289.                   datafirst[first] = datasim[k];
     
290.                   first++;
     
291.                 }
     
292.                 datafirst[first] = '\0';
     
293.                 for (p = douhao[2] + 1; p < douhao[3]; p++) //逗号3和逗号4之间的赋给datasecond
     
294.                 {
     
295.                   datasecond[second] = datasim[p];
     
296.                   second++;
     
297.                 }
     
298.                 datasecond[second] = '\0';
     
299.                 sleeptime = atoi(datafirst);
     
300.                 noisenum = atoi(datasecond);
     
301. 
     
302.               }
     
303.               if (datasim[i + 5] == '6')
     
304.               {
     
305.                 for (j = i; j < i + 25; j++)       //标记逗号在datasim里的位置
     
306.                 {
     
307.                   if (datasim[j] == ',')
     
308.                   {
     
309.                     douhao[douhaonum] = j;
     
310.                     douhaonum++;
     
311.                   }
     
312.                 }
     
313.                 for (k = douhao[1] + 3; k < douhao[2]; k++) //逗号2和逗号3之间的赋给datafirst
     
314.                 { //datafirst存储电话号码后九位的字符串
     
315.                   datafirst[first] = datasim[k];
     
316.                   first++;
     
317.                 }
     
318.                 datafirst[first] = '\0';
     
319.                 telnum = atol(datafirst);                 //后九位从字符串转换为十进制数
     
320.                 datajia2[4] = bitRead(telnum, 0) + bitRead(telnum, 1) * 2 + bitRead(telnum, 2) * 4 + bitRead(telnum, 3) * 8 + bitRead(telnum, 4) * 16 + bitRead(telnum, 5) * 32 + bitRead(telnum, 6) * 64 + bitRead(telnum, 7) * 128;
     
321.                 datajia2[3] = bitRead(telnum, 8) + bitRead(telnum, 9) * 2 + bitRead(telnum, 10) * 4 + bitRead(telnum, 11) * 8 + bitRead(telnum, 12) * 16 + bitRead(telnum, 13) * 32 + bitRead(telnum, 14) * 64 + bitRead(telnum, 15) * 128;
     
322.                 datajia2[2] = bitRead(telnum, 16) + bitRead(telnum, 17) * 2 + bitRead(telnum, 18) * 4 + bitRead(telnum, 19) * 8 + bitRead(telnum, 20) * 16 + bitRead(telnum, 21) * 32 + bitRead(telnum, 22) * 64 + bitRead(telnum, 23) * 128;
     
323.                 datajia2[1] = bitRead(telnum, 24) + bitRead(telnum, 25) * 2 + bitRead(telnum, 26) * 4 + bitRead(telnum, 27) * 8 + bitRead(telnum, 28) * 16 + bitRead(telnum, 29) * 32 + bitRead(telnum, 30) * 64 + bitRead(telnum, 31) * 128;
     
324.                 datajia2[0] = 0;
     
325.                 m = int(datasim[douhao[1] + 2]);
     
326.                 switch (m)
     
327.                 {
     
328.                   case 48:
     
329.                     {
     
330.                       datajia1[0] = 2; datajia1[1] = 84; datajia1[2] = 11;
     
331.                       datajia1[3] = 228; datajia1[4] = 0;
     
332.                       break;
     
333.                     }
     
334.                   case 49: {
     
335.                       datajia1[0] = 2; datajia1[1] = 143; datajia1[2] = 166;
     
336.                       datajia1[3] = 174; datajia1[4] = 0;
     
337.                       break;
     
338.                     }
     
339.                   case 50: {
     
340.                       datajia1[0] = 2; datajia1[1] = 203; datajia1[2] = 65;
     
341.                       datajia1[3] = 120; datajia1[4] = 0;
     
342.                       break;
     
343.                     }
     
344.                   case 51: {
     
345.                       datajia1[0] = 3; datajia1[1] = 6; datajia1[2] = 220;
     
346.                       datajia1[3] = 66; datajia1[4] = 0;
     
347.                       break;
     
348.                     }
     
349.                   case 52: {
     
350.                       datajia1[0] = 3; datajia1[1] = 66; datajia1[2] = 119;
     
351.                       datajia1[3] = 12; datajia1[4] = 0;
     
352.                       break;
     
353.                     }
     
354.                   case 53: {
     
355.                       datajia1[0] = 3; datajia1[1] = 126; datajia1[2] = 17;
     
356.                       datajia1[3] = 214; datajia1[4] = 0;
     
357.                       break;
     
358.                     }
     
359.                   case 54: {
     
360.                       datajia1[0] = 3; datajia1[1] = 185; datajia1[2] = 172;
     
361.                       datajia1[3] = 160; datajia1[4] = 0;
     
362.                       break;
     
363.                     }
     
364.                   case 55: {
     
365.                       datajia1[0] = 3; datajia1[1] = 245; datajia1[2] = 71;
     
366.                       datajia1[3] = 106; datajia1[4] = 0;
     
367.                       break;
     
368.                     }
     
369.                   case 56: {
     
370.                       datajia1[0] = 4; datajia1[1] = 48; datajia1[2] = 226;
     
371.                       datajia1[3] = 52; datajia1[4] = 0;
     
372.                       break;
     
373.                     }
     
374.                   case 57: {
     
375.                       datajia1[0] = 4; datajia1[1] = 108; datajia1[2] = 124;
     
376.                       datajia1[3] = 254; datajia1[4] = 0;
     
377.                       break;
     
378.                     }
     
379.                 }
     
380.                 datajia1[4] = datajia2[4];
     
381.                 for (n = 3; n > 0; n--)
     
382.                 {
     
383.                   datajia1[n] = datajia2[n] + datajia1[n] + datajia3[n];
     
384.                   if (datajia1[n] > 255)
     
385.                   {
     
386.                     datajia1[n] = datajia1[n] - 256;
     
387.                     datajia3[n - 1] = 1;
     
388.                   }
     
389.                 }
     
390.                 datajia1[0] = datajia1[0] + datajia3[0];
     
391.                 EEPROM.write(8, datajia1[0]);
     
392.                 delay(10);
     
393.                 EEPROM.write(9, datajia1[1]);
     
394.                 delay(10);
     
395.                 EEPROM.write(10, datajia1[2]);
     
396.                 delay(10);
     
397.                 EEPROM.write(11, datajia1[3]);
     
398.                 delay(10);
     
399.                 EEPROM.write(12, datajia1[4]);
     
400.                 delay(10);
     
401.               }
     
402.             }
     
403.     }
     
404.     datasim = "";
     
405. 
     
406.     mark = 0;
     
407.   }
     
408.   Serial.print("\r\n");
     
409. }
     
410. 
     
411. void PrintHex(unsigned long a)                                  //将ip从长整型转化为十六进制的8个字符
     
412. {
     
413.   iphex = "";
     
414.   char *Hex = "0123456789ABCDEF";
     
415.   if (!a)return;
     
416.   PrintHex(a / 16);
     
417.   iphex += Hex[a % 16];
     
418. }
     
419. 
     
420. int hextodec(char a, char b)
     
421. {
     
422.   int num = 0, c = 0, d = 0;
     
423.   if (a < 58)
     
424.     c = a - 48;
     
425.   else
     
426.     c = a - 55;
     
427.   if (b < 58)
     
428.     d = b - 48;
     
429.   else
     
430.     d = b - 55;
     
431.   num = c * 16 + d;
     
432.   return num;
     
433. }
     
434. 
     
435. void dectostring(int a, int b, int c, int d)                       //将十进制数转化成ip字符串
     
436. {
     
437. 
     
438.   int ipbit1 = 0, ipbit2 = 0, ipbit3 = 0;
     
439.   ip = "";
     
440.   ipbit3 = a % 10;
     
441.   ipbit2 = ((a - ipbit3) / 10) % 10;
     
442.   ipbit1 = (a - ipbit3 - 10 * ipbit2) / 100;
     
443.   if (ipbit1 != 0)
     
444.     ip += char(ipbit1 + 48);
     
445.   ip += char(ipbit2 + 48);
     
446.   ip += char(ipbit3 + 48);
     
447.   ip += '.';
     
448.   ipbit3 = b % 10;
     
449.   ipbit2 = ((b - ipbit3) / 10) % 10;
     
450.   ipbit1 = (b - ipbit3 - 10 * ipbit2) / 100;
     
451.   if (ipbit1 != 0)
     
452.     ip += char(ipbit1 + 48);
     
453.   ip += char(ipbit2 + 48);
     
454.   ip += char(ipbit3 + 48);
     
455.   ip += '.';
     
456.   ipbit3 = c % 10;
     
457.   ipbit2 = ((c - ipbit3) / 10) % 10;
     
458.   ipbit1 = (c - ipbit3 - 10 * ipbit2) / 100;
     
459.   if (ipbit1 != 0)
     
460.     ip += char(ipbit1 + 48);
     
461.   ip += char(ipbit2 + 48);
     
462.   ip += char(ipbit3 + 48);
     
463.   ip += '.';
     
464.   ipbit3 = d % 10;
     
465.   ipbit2 = ((d - ipbit3) / 10) % 10;
     
466.   ipbit1 = (d - ipbit3 - 10 * ipbit2) / 100;
     
467.   if (ipbit1 != 0)
     
468.     ip += char(ipbit1 + 48);
     
469.   ip += char(ipbit2 + 48);
     
470.   ip += char(ipbit3 + 48);
     
471. }
     
472. 
     
473. void xierueeprom()
     
474. {
     
475.   EEPROM.write(0, ipdec[0]);                   //将四段ip和两字节的端口号写入EEPROM
     
476.   delay(10);
     
477.   EEPROM.write(1, ipdec[1]);
     
478.   delay(10);
     
479.   EEPROM.write(2, ipdec[2]);
     
480.   delay(10);
     
481.   EEPROM.write(3, ipdec[3]);
     
482.   delay(10);
     
483.   EEPROM.write(4, porteeprom1);
     
484.   delay(10);
     
485.   EEPROM.write(5, porteeprom2);
     
486.   delay(10);
     
487.   EEPROM.write(6, sleeptime);                     //向EEPROM写入睡眠时间
     
488.   EEPROM.write(7, noisenum);                     //向EEPROM写入噪音的次数
     
489. }
     
490. 
     
491. int getpmnum()
     
492. {
     
493.   float ppm = 0;
     
494.   //  char s[32];
     
495.   float voltage = 0;
     
496.   float dustdensity = 0;
     
497.   float ppmpercf = 0;
     
498.   int i = 0, a = 0, b = 0;
     
499.   int delayTime = 280;
     
500.   int delayTime2 = 40;
     
501.   int dustVal = 0;
     
502.   float offTime = 9680;
     
503.   for (a = 0; a < 2; a++)
     
504.   {
     
505.     //  i = i + 1;
     
506.     digitalWrite(ledPower, LOW); // power on the LED++++++
     
507.     delayMicroseconds(delayTime);
     
508.     dustVal = analogRead(dustPin); // read the dust value
     
509.     //  ppm = ppm + dustVal;
     
510.     delayMicroseconds(delayTime2);
     
511.     digitalWrite(ledPower, HIGH); // turn the LED off
     
512.     delayMicroseconds(offTime);
     
513.     voltage = dustVal  * 0.0049;
     
514.     //  voltage = ppm / i * 0.0049;
     
515.     dustdensity = 0.17 * voltage - 0.1;
     
516.     ppmpercf = (voltage - 0.0256) * 120000;
     
517.     if (ppmpercf < 0)
     
518.       ppmpercf = 0;
     
519.     if (dustdensity < 0 )
     
520.       dustdensity = 0;
     
521.     if (dustdensity > 0.5)
     
522.       dustdensity = 0.5;
     
523.     //   dataString = "";
     
524.     // dataString += dtostrf(voltage, 9, 4, s);
     
525.     // dataString += ",";
     
526.     // dataString += dtostrf(dustdensity, 5, 2, s);
     
527.     //  dataString += ",";
     
528.     //  dataString += dtostrf(ppmpercf, 8, 0, s);
     
529.     //  i = 0;
     
530.     //  ppm = 0;
     
531.     delay(200);
     
532.   }
     
533.   b = dustdensity * 1000;
     
534.   return b;
     
535. }
     
536. 
     
537. int getnoisenum()
     
538. {
     
539.   String noise = "";               //噪声字符串
     
540.   int a = 0, i = 0, j = 0, k = 0, m = 0;
     
541.   int noiseint = 0;              //整型噪声值
     
542.   noise = "";
     
543.   while (!Serial2.available())
     
544.   {
     
545.   }
     
546.   while (Serial2.available() > 0)
     
547.   {
     
548. 
     
549.     noise += char(Serial2.read());
     
550.     delay(2);
     
551.   }
     
552.   noiseint = (noise[2] - 48) * 100 + (noise[3] - 48) * 10 + (noise[4] - 48);
     
553.   return noiseint;
     
554. }
     
555. 
     
556. void chushihua()              //初始化，如果EEPROM是255，加参数写入，然后将EEPROM的数据赋给全局变量。
     
557. {
     
558.   int a = 0, b = 0, port1 = 0, port2 = 0;
     
559.   unsigned int c = 0, i = 0;                //端口的整型
     
560.   int d = 0, e = 0;
     
561.   char f = 0;
     
562.   char aa[6];
     
563.   a = EEPROM.read(0);
     
564.   b = EEPROM.read(1);
     
565.   if ((a == 255) && (b == 255))
     
566.   {
     
567.     EEPROM.write(0, 219);              //初始化的数据，包括ip，Port，休眠时间（30），噪音采集次数（3）
     
568.     delay(10);
     
569.     EEPROM.write(1, 245);
     
570.     delay(10);
     
571.     EEPROM.write(2, 68);
     
572.     delay(10);
     
573.     EEPROM.write(3, 1);
     
574.     delay(10);
     
575.     EEPROM.write(4, 39);
     
576.     delay(10);
     
577.     EEPROM.write(5, 15);
     
578.     delay(10);
     
579.     EEPROM.write(6, 30);                 //休眠时间（30）
     
580.     delay(10);
     
581.     EEPROM.write(7, 3);                 //噪音采集次数（3）
     
582.     delay(10);
     
583.   }
     
584.   ipdec[0] = EEPROM.read(0);
     
585.   ipdec[1] = EEPROM.read(1);
     
586.   ipdec[2] = EEPROM.read(2);
     
587.   ipdec[3] = EEPROM.read(3);
     
588.   dectostring(ipdec[0], ipdec[1], ipdec[2], ipdec[3]);    //将十进制数转化成ip字符串
     
589.   porteeprom1 = EEPROM.read(4);
     
590.   porteeprom2 = EEPROM.read(5);
     
591.   c = porteeprom1 * 256 + porteeprom2;                  //itoa只能取到3万多，所以要把最高位单独列出来
     
592.   e = c % 10000;
     
593.   d = (c - e) / 10000;
     
594.   f = d + 48;
     
595.   itoa(e, aa, 10);
     
596.   if (d != 0)
     
597.     port += f;
     
598.   for (i = 0; i < 6; i++)
     
599.   {
     
600.     if (aa[i] != '\0')
     
601.       port += aa[i];
     
602.   }
     
603.   sleeptime = EEPROM.read(6);
     
604.   noisenum = EEPROM.read(7);
     
605. }
     
606. 
     
607. void package()                                  //将数据组包
     
608. {
     
609.   int i = 0;
     
610.   int j = 0;
     
611.   datasend[0] = 11;
     
612.   datasend[1] = 1;
     
613.   datasend[2] = EEPROM.read(8);
     
614.   datasend[3] = EEPROM.read(9);
     
615.   datasend[4] = EEPROM.read(10);
     
616.   datasend[5] = EEPROM.read(11);
     
617.   datasend[6] = EEPROM.read(12);
     
618.   datasend[7] = pmh;
     
619.   datasend[8] = pml;
     
620.   datasend[9] = noise;
     
621.   for (i = 0; i < 10; i++)
     
622.     j = datasend[i] + j;
     
623.   datasend[10] = j ^ 169;
     
624. }
     
625. 
     
626. void tcplink()                                //与数据中心进行TCP通信传输数据接收配置参数
     
627. {
     
628.   int i = 0;
     
629.   unsigned int c = 0;                //端口的整型
     
630.   int d = 0, e = 0;
     
631.   char f = 0;
     
632.   char aa[6];
     
633.   Serial3.print("AT+CIPMODE=1\r\n");
     
634.   delay(2000);
     
635.   Serial3.print("AT+CIPSTART=");
     
636.   Serial3.print('"');
     
637.   Serial3.print("TCP");
     
638.   Serial3.print('"');
     
639.   Serial3.print(',');
     
640.   Serial3.print('"');
     
641.   Serial3.print(ip);
     
642.   Serial3.print('"');
     
643.   Serial3.print(',');
     
644.   Serial3.print(port);
     
645.   Serial3.print("\r\n");
     
646.   while (1)
     
647.   {
     
648.     if (Serial3.find("CONNECT"))
     
649.       break;
     
650.     delay(10);
     
651.   }
     
652.   for (i = 0; i < 11; i++)
     
653.     Serial3.write(datasend[i]);
     
654.   while (1)
     
655.   {
     
656.     i = 0;
     
657.     while (!Serial3.available())
     
658.     {
     
659.     }
     
660.     while (Serial3.available() > 0)
     
661.     {
     
662.       datarece[i] = Serial3.read();
     
663.       i++;
     
664.       delay(2);
     
665.     }
     
666.     //     for (j = 0; j < i; j++)
     
667.     //       Serial.println(datarece[j]);
     
668.     if (datarece[0] == 2)
     
669.     {
     
670.       if (datarece[1] == 129)
     
671.         for (i = 0; i < 11; i++)
     
672.           Serial3.write(datasend[i]);
     
673.       if (datarece[1] == 161)
     
674.         break;
     
675.     }
     
676.     if (datarece[0] == 8)
     
677.     {
     
678.       EEPROM.write(0, datarece[2]);
     
679.       delay(10);
     
680.       EEPROM.write(1, datarece[3]);
     
681.       delay(10);
     
682.       EEPROM.write(2, datarece[4]);
     
683.       delay(10);
     
684.       EEPROM.write(3, datarece[5]);
     
685.       delay(10);
     
686.       EEPROM.write(4, datarece[6]);
     
687.       delay(10);
     
688.       EEPROM.write(5, datarece[7]);
     
689.       delay(10);
     
690.       dectostring(datarece[2], datarece[3], datarece[4], datarece[5]);    //将十进制数转化成ip字符串
     
691.       port = "";
     
692.       porteeprom1 = datarece[6];
     
693.       porteeprom2 = datarece[7];
     
694.       c = porteeprom1 * 256 + porteeprom2;                  //itoa只能取到3万多，所以要把最高位单独列出来
     
695.       e = c % 10000;
     
696.       d = (c - e) / 10000;
     
697.       f = d + 48;
     
698.       itoa(e, aa, 10);
     
699.       if (d != 0)
     
700.         port += f;
     
701.       for (i = 0; i < 6; i++)
     
702.       {
     
703.         if (aa[i] != '\0')
     
704.           port += aa[i];
     
705.       }
     
706.       Serial3.write(2);               //配置ip和Port并发出响应
     
707.       Serial3.write(162);
     
708.       if (datarece[1] == 162)
     
709.         break;
     
710.     }
     
711.     if (datarece[0] == 4)
     
712.     {
     
713.       EEPROM.write(6, datarece[2]);
     
714.       delay(10);
     
715.       EEPROM.write(7, datarece[3]);
     
716.       delay(10);
     
717.       sleeptime = datarece[2];
     
718.       noisenum = datarece[3];
     
719.       Serial3.write(2);                //配置休眠时间和噪音采集次数并发出响应
     
720.       Serial3.write(163);
     
721. 
     
722.       if (datarece[1] == 163)
     
723.         break;
     
724.     }
     
725.   }
     
726. }
     
727. 
     
728. int maxnoise(int a)
     
729. {
     
730.   unsigned char nn[100] = {0}, b = 0;
     
731.   int i = 0;
     
732.   for (i = 0; i < a; i++)
     
733.   {
     
734.     nn[i] = getnoisenum();
     
735.     delay(16000);
     
736.   }
     
737.   for (i = 0; i < a; i++)
     
738.   {
     
739.     b = max(b, nn[i]);
     
740.   }
     
741.   return b;
     
742. }
     
743. 
     
744. void delallsms()                                   //删除所有短信
     
745. {
     
746.   Serial3.print("AT+CMGDA=");
     
747.   Serial3.print('"');
     
748.   Serial3.print("DEL ALL");
     
749.   Serial3.print('"');
     
750.   Serial3.print("\r\n");
     
751. }
     
752. 
     
753. void sleepmode(int a)                           //进入休眠模式
     
754. {
     
755.   int i = 0;
     
756.   for(i = 0;i < (2*a);i++)
     
757.     Narcoleptic.delay(30000);
     
758. }
     
759. 
     
760. void chulismsip()                               //每隔一段时间读短信，有电话号码就跳出否则一直循环
     
761. {
     
762.   while (1)
     
763.   {
     
764.     int a = 0;
     
765.     a = EEPROM.read(8);
     
766.     if (a == 255)
     
767.     {
     
768.       duanxinnum = SMSnum();
     
769.       if ((duanxinnum > 0) && (duanxinnum < 10))
     
770.         chuliduanxin(duanxinnum);
     
771.     }
     
772.     else
     
773.       break;
     
774.     a = EEPROM.read(8);
     
775.     if (a == 255)
     
776.       sleepmode(30);
     
777.     else
     
778.       break;
     
779.   }
     
780. }

复制代码

毛驴

代码有点长，参考一下就可以了

毛驴

34行和46到52行屏蔽了，下面的TCP连接就行，恢复短信操作后就不行了

毛驴

另外，我单独用串口调试工具操作sim900a，就不存在这个问题，短信操作之后TCP也能连上啊。

zoologist

内存爆了？

毛驴

不是，全局变量用了10%，程序存储空间用了6%

DEMON_BY

想问一下ardunio uno和sim900a您是怎么连接的用的哪些口

DEMON_BY

'Serial2'was not declared in this scope请问下这个是怎么回事

毛驴

'Serial2只有arduino mega 2560里才有，Uno只有一对串口，mega 2560有4对，你是不是用Uno的，极客工坊的知识库里有。

毛驴

你如果想要在Uno用多对串口，可以用软串口库试试。