标题: 51单片机gsm-A6+lcd2864智能花盆程序代码 [打印本页]

---

作者: songwentai    时间: 2017-9-1 12:32
标题: 51单片机gsm-A6+lcd2864智能花盆程序代码
51单片机智能花盆程序代码，内有详细介绍，

此系统由51单片机，lcd2864 gsm-a6，各种传感器组成

1. #include <reg52.h>
   
2. #include "string.h"
   
3. #include<intrins.h>
   
4. #define uchar unsigned char
   
5. #define uint unsigned int
   
6. 
   
7. typedef         unsigned char        u8;
   
8. typedef         unsigned int        u16;
   
9. typedef         unsigned long        u32;
   
10. 
    
11. 
    
12. #define Buf_Max                    50         //串口1缓存长度
    
13. #define STABLE_TIMES          15        //等待A6上电后稳定，再进行自适应波特率            
    
14. #define SEND_AT_TIMES           30    //发送多少个AT指令进行自适应
    
15. #define SEND_AT_INTERVAL  2     //2代表的是2*20ms  自适应的时候，每个AT指令的间隔时间
    
16. 
    
17. 
    
18. //串口1发送回车换行
    
19. #define UART1_SendLR() UART1_SendData(0X0D);\
    
20.                                                                                          UART1_SendData(0X0A)
    
21. 
    
22. sbit ds   = P2^2;           //ds18b20位声明
    
23. sbit dula = P2^6;           //数码管位声明
    
24. sbit wei = P2^7;
    
25. sbit beep=P2^3;
    
26. sbit lcden=P3^4;           //液晶使能端声明
    
27. sbit lcdrs=P3^5;                 //寄存器使能端声明
    
28. sbit lcdrw=P3^6;                //读写端
    
29. sbit lcdPSB=P3^7;                //串并口位声明
    
30. sbit key1=P3^0;
    
31. sbit key2=P3^1;                         
    
32. sbit sda=P2^0;                         //I2C数据端口
    
33. sbit scl=P2^1;//I2C时钟
    
34. sbit LED0 = P1^0;
    
35. sbit LED1 = P1^1;
    
36. sbit LED3 = P1^3;
    
37. sbit p5 = P1^5;
    
38. sbit p6 = P1^6;
    
39. sbit p7= P1^7  ;
    
40. sbit p4=P1^4;
    
41. bit flag;
    
42. 
    
43. 
    
44. uint xdata aa,bb,q,w=10,w0=30,w1,w2,w3,w4,s=30,s0=60,s1,s2,s3,s4,g,g1,g2,temp,DP,k1=2,k2=2,a=0,b=0,c=0;
    
45. unsigned int code dofly_DuanMa[16]={0,1,2,3,4,5,6,7,8,9,45,46,66,47,88,99};// 显示段码值0~9
    
46. unsigned char  irtime;        //红外用全局变量
    
47. 
    
48. bit irpro_ok,irok;
    
49. unsigned char xdata IRcord[4];
    
50. unsigned char xdata irdata[33];
    
51. 
    
52. uchar temp1;
    
53. 
    
54. uchar xdata dis1[]={"温度:    C     " };
    
55. uchar xdata dis2[]={"湿度：   %      " };   
    
56. uchar xdata dis3[]={"光强：         " };  
    
57. uchar xdata dis4[]={"自动模式:   关 " };        //液晶显示部分
    
58. uchar xdata dis5[]={"温度: 10-30C   " };
    
59. uchar xdata dis6[]={"湿度：30-60%   " };   
    
60. uchar xdata dis7[]={"补光:       关 "};
    
61. uchar  dis8[]={"自动模式:   开 "};
    
62. uchar  dis9[]={"补光:       开 "};
    
63. 
    
64. xdata u8 Uart1_Buf[Buf_Max];
    
65. //u8 Register_Flag=0;  //A6  注册标志位  1 ：注册成功  3：注册失败   5：注册成功，但处于漫游状态下，无法拨打电话发短信
    
66. u8 First_Int = 0;
    
67. u8 xdata i,ret;
    
68. static u8  *phone_num = "AT+CMGS=\"***********\""; //拨打电话，修改这里可以修改拨打的电话。
    
69. const char *AT_CMGS="AT+CMGS=27";
    
70. const char *pdu_content0="0011000D91687158538312F70008AA0C4E3B4EBAFF0C62116E344E86" ;
    
71. const char *AT_CMG="AT+CMGS=31";
    
72. const char  *pdu_content1="0011000D91687158538312F70008AA104E3B4EBAFF0C62115FEB70ED6B7B4E86";
    
73. const char  *pdu_content2="0011000D91687158538312F70008AA104E3B4EBAFF0C62115FEB51BB6B7B4E86";
    
74. u8  receive_message_mode = 0;
    
75. 
    
76. u8  ledon_flag = 0;
    
77. /*************        本地函数声明        **************/
    
78. void delay_ms(u16 ms);   //延时ms个20ms  ms*20ms
    
79. void CLR_Buf(void);      //清串口接收缓存
    
80. u8          Find(u8 *a);        //查找字符串
    
81. void UART1_SendData(u8 dat);   //串口1发送 1字节
    
82. void UART1_SendString(char *s);//串口1发送 字符串
    
83. void UART1_Send_Command(char *s);
    
84. u8   UART1_Send_AT_Command(u8 *b,u8 *a,u8 wait_time,u16 interval_time);//a6 at命令发送
    
85. void Wait_CREG(void);
    
86. 
    
87. 
    
88. void adjust_A6_buadrate(void)
    
89. {
    
90.         u8 ret;
    
91. 
    
92.         ret = UART1_Send_AT_Command("AT","OK",SEND_AT_TIMES,SEND_AT_INTERVAL);
    
93.         if(ret == 1)
    
94.         {
    
95.                 LED0 = 0;
    
96.         }
    
97.         else
    
98.         {
    
99.                 LED0 = 1;
    
100.         }
     
101. }
     
102. 
     
103. 
     
104. /***************************************************************
     
105. 注：当然你可以返回其他值，来确定到底是哪一步发送指令出现失败了。
     
106. ****************************************************************/
     
107. u8 send_pdu_message0(char *content)
     
108. {
     
109.         u8 ret;
     
110.         char content_len[3];//计算字符串的长度，暂时支持的短信内容的字符数为2位，也就是99个字节，可以根据自己爱好进行修改
     
111.         u8 end_char[2];
     
112.         idata char *con;
     
113.         idata u8 i;
     
114.        
     
115.         end_char[0] = 0x1A;
     
116.         end_char[1] = '\0';
     
117.        
     
118.         ret = 0;
     
119.        
     
120.         con = content;
     
121.         i = 0;
     
122. ret = UART1_Send_AT_Command("AT+CMGF=0","OK",3,50);//配置为PDU模式
     
123.         if(ret == 0)
     
124.         {
     
125.                 return 0;
     
126.         }
     
127.        
     
128.         ret = UART1_Send_AT_Command(AT_CMGS,">",3,50);//发送字符个数指令
     
129.         if(ret == 0)
     
130.         {
     
131.                 return 0;
     
132.         }
     
133.        
     
134.         UART1_SendString(content);                                                 //发送具体的内容
     
135.         ret = UART1_Send_AT_Command(end_char,"OK",3,250);//发送结束符，等待返回ok,等待5S发一次，因为短信成功发送的状态时间比较长
     
136.        
     
137.         return ret;
     
138. }
     
139. 
     
140. u8 send_pdu_message1(char *content)
     
141. {
     
142.         u8 ret;
     
143.         char content_len[3];//计算字符串的长度，暂时支持的短信内容的字符数为2位，也就是99个字节，可以根据自己爱好进行修改
     
144.         u8 end_char[2];
     
145.         idata char *con;
     
146.         idata u8 i;
     
147.        
     
148.         end_char[0] = 0x1A;
     
149.         end_char[1] = '\0';
     
150.        
     
151.         ret = 0;
     
152.        
     
153.         con = content;
     
154.         i = 0;
     
155. ret = UART1_Send_AT_Command("AT+CMGF=0","OK",3,50);//配置为PDU模式
     
156.         if(ret == 0)
     
157.         {
     
158.                 return 0;
     
159.         }
     
160.        
     
161.         ret = UART1_Send_AT_Command(AT_CMG,">",3,50);//发送字符个数指令
     
162.         if(ret == 0)
     
163.         {
     
164.                 return 0;
     
165.         }
     
166.        
     
167.         UART1_SendString(content);                                                 //发送具体的内容
     
168.         ret = UART1_Send_AT_Command(end_char,"OK",3,250);//发送结束符，等待返回ok,等待5S发一次，因为短信成功发送的状态时间比较长
     
169.        
     
170.         return ret;
     
171. }
     
172. 
     
173. void Ir_work(void);
     
174.   
     
175.   void delay()  //5us
     
176. {;;}
     
177. void delay1(uint z)//1ms
     
178. {
     
179.         uint x,y;
     
180.         for(x=z;x>0;x--)
     
181.                 for(y=120;y>0;y--);       
     
182. }
     
183.    void write_com(uchar com)         //写指令数据到液晶
     
184. {    lcdrs=0;
     
185.      lcdrw=0;
     
186.      lcden=0;
     
187.      P0=com;
     
188.      delay1(5);
     
189.      lcden=1;
     
190.     delay1(5);
     
191.      lcden=0;
     
192. }
     
193. void write_data(uchar date)                 //写显示数据到液晶
     
194. {
     
195.     lcdrs=1;
     
196.     lcdrw=0;
     
197.     lcden=0;
     
198.     P0=date;
     
199.     delay1(5);
     
200.     lcden=1;
     
201.     delay1(5);
     
202.     lcden=0;
     
203. }
     
204. void lcd_pos(uchar X,uchar Y)         //液晶位置选择
     
205. {
     
206.     uchar pos;
     
207.         if(X==0)
     
208.     {X=0x80;}
     
209.      else if(X==1)
     
210.     {X=0x90;  }
     
211.     else if(X==2)
     
212.     {X=0x88;}
     
213.     else if(X==3)
     
214.     {X=0x98;}
     
215.     pos=X+Y;
     
216.    write_com(pos);
     
217. }
     
218. 
     
219.    void init1()                                   //液晶初始化
     
220. {dula=0;
     
221.   wei=0;
     
222. lcdPSB=1;
     
223. write_com(0x30)          ;
     
224. delay1(5);
     
225. write_com(0x0C);
     
226. delay1(5);
     
227. write_com(0x01);
     
228. delay1(5);
     
229. 
     
230. 
     
231. }
     
232.    void start()                                  // PCF8591  起始信号
     
233. {
     
234.         scl=1;
     
235.         _nop_();
     
236.         sda=1;
     
237.         delay();
     
238.         sda=0;
     
239.         delay();
     
240.         scl=0;
     
241.         _nop_();
     
242. }
     
243. void stop()                                           //PCF8591终止信号
     
244. {
     
245.         scl=1;
     
246.         _nop_();
     
247.         sda=0;
     
248.         delay();
     
249.         sda=1;
     
250.         delay();
     
251. }
     
252. void respons()                           //应答信号
     
253. {
     
254.         scl=1;
     
255.         _nop_();
     
256.         sda=0;
     
257.         delay();
     
258.         scl=0;
     
259.         _nop_();
     
260. }
     
261. void norespons()
     
262. {
     
263.         scl=1;
     
264.         _nop_();
     
265.         sda=1;
     
266.         delay();
     
267. }
     
268. void init()                                  //PCF8591初始化
     
269. {
     
270.         scl=1;
     
271.         _nop_();
     
272.         sda=1;
     
273.         _nop_();
     
274. }
     
275. void write_byte(uchar dat)           //主机向从机发送数据
     
276. {
     
277.         uchar i,tem;
     
278.         tem=dat;
     
279.         for(i=0;i<8;i++)
     
280.         {
     
281.                 scl=0;
     
282.                 _nop_();
     
283.                 if((tem&0x80)==0x80)
     
284.                         sda=1;          //写1
     
285.                 else
     
286.                         sda=0;          //写0
     
287.                 scl=1;
     
288.                 _nop_();
     
289.                 tem<<=1;
     
290.         }
     
291.         scl=0;
     
292.         _nop_();
     
293. }
     
294. uchar read_byte()        /*读一个字节（从机向主机）由高到低位*/
     
295. {
     
296.         uchar dat,i;
     
297.         sda=1;
     
298.         _nop_();
     
299.         scl=0;
     
300.         _nop_();
     
301.         for(i=0;i<8;i++)
     
302.         {
     
303.                 scl=1;
     
304.                 _nop_();
     
305.                 if(sda)
     
306.                         dat|=0x01;
     
307.                 if(i<7)
     
308.                          dat<<=1;
     
309.                 scl=0;
     
310.                 _nop_();       
     
311.         }
     
312.         return dat;
     
313. }
     
314. 
     
315. 
     
316. 
     
317. uchar ADC_read(uchar com)        /*单片机读PCF8591的AD数据*/
     
318. {
     
319.         uchar dat;
     
320.         dat=com;
     
321.         start();
     
322.         write_byte(0x90);
     
323.         respons();
     
324.         write_byte(com);
     
325.         respons();
     
326.         start();
     
327.         write_byte(0x91);
     
328.         respons();
     
329.         dat=read_byte();
     
330. 
     
331.         norespons();
     
332.         stop();
     
333.         return dat;
     
334. }
     
335. 
     
336.   
     
337. void TempDelay(uchar us)
     
338. {
     
339.         while(us--); //6.51us
     
340. }
     
341. 
     
342. void ds_reset()          //DS18B20初始化
     
343. {
     
344.         ds=1;
     
345.         _nop_();
     
346.         ds=0;
     
347.         TempDelay(80);//520us
     
348.         ds=1;
     
349.         TempDelay(5);
     
350.         if(ds==0)
     
351.                 flag=1;
     
352.         else
     
353.                 flag=0;
     
354.         TempDelay(20);
     
355.         ds=1;
     
356. }
     
357. bit ds_read_bit()                //读一位数据
     
358. {
     
359.         bit dat;
     
360.         ds=0;
     
361.         _nop_();
     
362.         _nop_();
     
363.         ds=1;
     
364.         _nop_();
     
365.         dat=ds;
     
366.         TempDelay(12);
     
367.         return dat;
     
368. }
     
369. uchar ds_read_byte()           //读1个字节数据
     
370. {
     
371.         uchar i,j,value;
     
372.         for(i=0;i<8;i++)
     
373.         {
     
374.                 j=ds_read_bit();
     
375.                 value=(j<<7)|(value>>1);
     
376.         }
     
377.         return value;
     
378. }
     
379. void ds_write_byte(uchar dat)         //向DS18B20写数据
     
380. {
     
381.         uchar i,onebit;
     
382.         for(i=0;i<8;i++)
     
383.         {
     
384.                 onebit=dat&0x01;
     
385.                 if(onebit)           //写1
     
386.                 {
     
387.                         ds=0;
     
388.                         TempDelay(1);
     
389.                         ds=1;
     
390.                         _nop_();
     
391.                 }
     
392.                 else  //写0
     
393.                 {
     
394.                         ds=0;
     
395.                         TempDelay(11);
     
396.                         ds=1;
     
397.                         _nop_();
     
398.                 }
     
399.                 dat>>=1;
     
400.         }
     
401. }
     
402. void ds_change()         //温度获取和转换
     
403. {
     
404.         ds_reset();
     
405.         ds_write_byte(0xcc);
     
406.         ds_write_byte(0x44);
     
407. }
     
408. 
     
409. uint get_temperature()          //读取温度数据
     
410. {
     
411.         uchar a,b;
     
412.         float temperature;
     
413.         ds_reset();
     
414.         ds_write_byte(0xcc);
     
415.         ds_write_byte(0xbe);
     
416.         a=ds_read_byte();
     
417.         b=ds_read_byte();
     
418.         temp=b;
     
419.         temp<<=8;
     
420.         temp|=a;
     
421.         temperature=temp*0.0625;
     
422.         temp=temperature*10+0.5;
     
423.         temp=temperature+0.05;
     
424.        
     
425.         return temp;
     
426. }
     
427. 
     
428. 
     
429. 
     
430. void Ir_work(void);
     
431. void Ircordpro(void);
     
432. 
     
433. void tim0_isr (void) interrupt 1 using 1
     
434. {
     
435.   irtime++;  //用于计数2个下降沿之间的时间
     
436. }
     
437. 
     
438. void EX0_ISR (void) interrupt 0 //外部中断0服务函数
     
439. {
     
440.         static unsigned char  i;             //接收红外信号处理
     
441.         static bit startflag;                //是否开始处理标志位
     
442. 
     
443.         if(startflag)                        
     
444.         {
     
445.                 if(irtime<63&&irtime>=33)//引导码 TC9012的头码，9ms+4.5ms
     
446.             i=0;
     
447.                     irdata[i]=irtime;//存储每个电平的持续时间，用于以后判断是0还是1
     
448.                     irtime=0;
     
449.                     i++;
     
450.                            if(i==33)
     
451.                       {
     
452.                                   irok=1;
     
453.                                 i=0;
     
454.                           }
     
455.         }
     
456.         else
     
457.         {
     
458.                 irtime=0;
     
459.                 startflag=1;
     
460.         }
     
461. }
     
462. 
     
463. void Uart1Init(void)                //9600bps@11.05926MHz
     
464. {
     
465.         PCON =0x80;                //
     
466.         SCON = 0x50;                //
     
467. 
     
468. TMOD=0x22;
     
469.         TL1 = 0xFA;                  //
     
470.         TH1 = 0xFA;                  //
     
471.                 TH0=0x00; //重载值
     
472.         TL0=0x00; //初始化值
     
473.   
     
474.         IE = 0x90;
     
475.         ET1 = 0;                    //
     
476.         TI=1;
     
477.         TR1 = 1;                    //
     
478.         ES  = 1;                        //
     
479. }
     
480. 
     
481. 
     
482. void TIM0init(void)//定时器0初始化
     
483. {
     
484.         TMOD=0x22;//定时器0工作方式2，TH0是重装值，TL0是初值
     
485.         TH0=0x00; //重载值
     
486.         TL0=0x00; //初始化值
     
487.         ET0=1;    //开中断
     
488.         TR0=1;   
     
489. }
     
490. void EX0init(void)
     
491. {
     
492. IT0 = 1;   //指定外部中断0下降沿触发，INT0 (P3.2)
     
493. EX0 = 1;   //使能外部中断
     
494. EA = 1;    //开总中断
     
495. }
     
496. 
     
497. 
     
498. void Ir_work(void)//红外键值散转程序
     
499. {
     
500.        switch(IRcord[2])//判断第三个数码值
     
501.                  {
     
502.                          case 0x45:DP=dofly_DuanMa[1];break;//1 显示相应的按键值
     
503.                          case 0x46:DP=dofly_DuanMa[2];break;//2
     
504.                          case 0x47:DP=dofly_DuanMa[3];break;//3
     
505.                          case 0x44:DP=dofly_DuanMa[4];break;//4
     
506.                          case 0x40:DP=dofly_DuanMa[5];break;//5
     
507.                          case 0x43:DP=dofly_DuanMa[6];break;//6
     
508.                          case 0x07:DP=dofly_DuanMa[7];break;//7
     
509.                          case 0x15:DP=dofly_DuanMa[8];break;//8
     
510.                          case 0x09:DP=dofly_DuanMa[9];break;//9
     
511.                          case 0x19:DP=dofly_DuanMa[0];break;//0
     
512.                           case 0x18:DP=dofly_DuanMa[15];break;//上
     
513.                          case 0x08:DP=dofly_DuanMa[10];break;//左
     
514.                          case 0x5a:DP=dofly_DuanMa[11];break;//右
     
515.                      case 0x16:DP=dofly_DuanMa[12];break;//*
     
516.                      case 0x52:DP=dofly_DuanMa[13];break;//下
     
517.                          case 0x0d:DP=dofly_DuanMa[14];break;//#
     
518.                           
     
519.              default:break;
     
520. 
     
521.                          }
     
522. 
     
523.                   irpro_ok=0;//处理完成标志
     
524. 
     
525. }
     
526. void Ircordpro(void)//红外码值处理函数
     
527. {
     
528.         unsigned char i, j, k,cord,value;
     
529.         k=1;
     
530.         for(i=0;i<4;i++)      //处理4个字节
     
531.         {
     
532.                 for(j=1;j<=8;j++) //处理1个字节8位
     
533.                 {
     
534.                         cord=irdata[k];
     
535.                         if(cord>7)//大于某值为1，这个和晶振有绝对关系，这里使用12M计算，此值可以有一定误差
     
536.                         value=value|0x80;
     
537.                         if(j<8)
     
538.                         {
     
539.                                 value>>=1;
     
540.                         }
     
541.                         k++;
     
542.                 }
     
543.                 IRcord[i]=value;
     
544.                 value=0;     
     
545.         }
     
546.         irpro_ok=1;//处理完毕标志位置1
     
547. }
     
548. 
     
549. 
     
550. 
     
551.     void fk()
     
552. {if(irok)                       
     
553.                 {   
     
554.                         Ircordpro();
     
555.                         irok=0;
     
556.                 }
     
557.                 if(irpro_ok)                  
     
558.                
     
559.         Ir_work();}
     
560. 
     
561. /**********************************************/
     
562. /*设计思路：
     
563. (0)进行串口、定时器初始化工作。
     
564. (1)开机等待15秒，等待模块准备好。
     
565. (2)发送AT指令，让模块进行自适应波特率为9600
     
566. (3)发送相应的指令。
     
567. ************************************************/
     
568. void main(void)
     
569. {
     
570. uchar dat,dat1,dat2;
     
571. aa=p5=p6=p7=0;          
     
572.                   delay1(5);
     
573.   init();
     
574.     init1();
     
575.        
     
576.         ds_change();
     
577. 
     
578. 
     
579. 
     
580.          Uart1Init();
     
581.                  TIM0init();//初始化定时器
     
582.                          EX0init(); //初始化外部中断
     
583.          delay1(1000);
     
584.            for(i = 0;i < STABLE_TIMES;i++)//等待网络稳定
     
585.         {
     
586.                 delay_ms(50);
     
587.         }
     
588.        
     
589.         //自适应波特率
     
590.         adjust_A6_buadrate();
     
591.         //等待GSM注册成功
     
592.         Wait_CREG();
     
593.         //设置存储位置，不做返回值判断了
     
594.         ret = UART1_Send_AT_Command("AT+CPMS=\"SM\",\"ME\",\"SM\"","OK",3,100);//AT+CPMS="SM","ME","SM"
     
595. 
     
596. 
     
597. 
     
598.         while(1)
     
599.         {                     delay1(5);
     
600.                          
     
601.                    if(k1==2)                                                                          
     
602. for(i=0;i<15;i++)
     
603.         write_data(dis4[i]);
     
604.           
     
605. if(k1==1)
     
606. for(i=0;i<15;i++)               
     
607. write_data(dis8[i]);
     
608. delay1(5) ;
     
609. 
     
610.                         temp1=temp;
     
611.                         if((temp1!=255)&&(temp1!=85))
     
612.                                      dat1=temp1;
     
613.                                 //温度显示模块
     
614.                         dis1[6]=(uint) (0x30+dat1/100)        ;
     
615.                         dis1[7]=(uint)(0x30+dat1%100/10);
     
616.                         dis1[8]=(uint)(0x30+dat1%100%10);
     
617.        
     
618.    
     
619.             lcd_pos(1,0);
     
620.                         for(i=0;i<15;i++)
     
621.                         {write_data(dis1[i]);         }
     
622.                   delay1(100);
     
623.                 ds_change();
     
624. 
     
625. 
     
626.                 get_temperature();
     
627.        
     
628.                                     dat2=-ADC_read(0x02);                 //湿度显示模块
     
629.                        
     
630.                         dis2[7]=(uint)(0x30+dat2/2%100/10);
     
631.                         dis2[8]=(uint)(0x30+dat2/2%100%10);
     
632.                         lcd_pos(2,0);
     
633.                         for(i=0;i<15;i++)
     
634.                         {write_data(dis2[i]);         }       
     
635.                        
     
636.                          delay1(5);
     
637.                           dat=0;          
     
638.                  dat=-ADC_read(0x03);        //光强显示模块
     
639.                      dis3[6]=(uint) (0x30+dat/100)        ;
     
640.                      dis3[7]=(uint)(0x30+dat%100/10);
     
641.                          dis3[8]=(uint)(0x30+dat%100%10);
     
642.              lcd_pos(3,0);
     
643.                          for(i=0;i<15;i++)
     
644.                          {write_data(dis3[i]);         }
     
645.        
     
646.                                
     
647. 
     
648.                                  
     
649.   //控制界面
     
650. 
     
651.                      fk();
     
652. 
     
653.      if (DP==66)       
     
654.          
     
655. {          
     
656.          
     
657. 
     
658. lcd_pos(0,0);
     
659.            if(k1==2)                                                                          
     
660. for(i=0;i<15;i++)
     
661.         write_data(dis4[i]);
     
662.           
     
663. if(k1==1)
     
664. for(i=0;i<15;i++)               
     
665. write_data(dis8[i]);
     
666. delay1(5) ;
     
667. 
     
668.                                                                                                          
     
669. 
     
670. lcd_pos(1,0);
     
671.                         for(i=0;i<15;i++)
     
672.                         {write_data(dis5[i]);         }
     
673.                                 delay1(5);
     
674. 
     
675. lcd_pos(2,0);
     
676.         for(i=0;i<15;i++)
     
677.                         {write_data(dis6[i]);         }
     
678.                                 delay1(5)  ;
     
679. 
     
680. 
     
681. lcd_pos(3,0);
     
682.         if(k2==2)        {                                                                  
     
683. for(i=0;i<14;i++)
     
684.         write_data(dis7[i]);        }
     
685. 
     
686. if(k2==1)  {
     
687. for(i=0;i<14;i++)               
     
688. write_data(dis9[i]);
     
689. 
     
690.                                  }
     
691.                                 delay1(5) ;
     
692. 
     
693. 
     
694.   do{
     
695.          do{
     
696.       fk();
     
697.                         }while(DP==66);
     
698.           
     
699. 
     
700. if(DP==45)
     
701.         {       
     
702.         while(DP==45)
     
703.         fk();
     
704.         w1=DP;       
     
705.                 lcd_pos(1,0);
     
706. 
     
707.                 dis5[6]=(0x30+DP);       
     
708.                 for(i=0;i<15;i++)
     
709.            write_data(dis5[i]);
     
710.                  delay1(5) ;
     
711. 
     
712.              while(DP==w1)
     
713.                 fk();
     
714.                 w2=DP ;
     
715.                 lcd_pos(1,0);
     
716.                         dis5[7]=(0x30+DP);       
     
717.                 for(i=0;i<15;i++)
     
718.            write_data(dis5[i]);
     
719.                    w=w1*10+w2;
     
720.                 delay1(5) ;
     
721. 
     
722.                         while(DP==w2)
     
723.                 fk();
     
724.                 w3=DP ;
     
725.                 lcd_pos(1,0);
     
726.                         dis5[9]=(0x30+DP);       
     
727.                 for(i=0;i<15;i++)
     
728.            write_data(dis5[i]);
     
729.            delay1(5) ;
     
730. 
     
731.                    while(DP==w3)
     
732.                 fk();
     
733.                 w4=DP ;
     
734.                 lcd_pos(1,0);
     
735.                         dis5[10]=(0x30+DP);       
     
736.                 for(i=0;i<15;i++)
     
737.            write_data(dis5[i]);
     
738.                    w0=w3*10+w4;
     
739.                 delay1(5) ;
     
740. 
     
741. 
     
742. 
     
743. 
     
744.                           }
     
745.                
     
746. if(DP==46)                       
     
747.         {       
     
748.         while(DP==46)
     
749.         fk();
     
750.         s1=DP;       
     
751.                 lcd_pos(2,0);
     
752. 
     
753.                 dis6[6]=(0x30+DP);       
     
754.                 for(i=0;i<10;i++)
     
755.            write_data(dis6[i]);
     
756.                  delay1(5) ;
     
757. 
     
758.              while(DP==s1)
     
759.                 fk();
     
760.                 s2=DP ;
     
761.                 lcd_pos(2,0);
     
762.                         dis6[7]=(0x30+DP);       
     
763.                 for(i=0;i<10;i++)
     
764.            write_data(dis6[i]);
     
765.                     s=s1*10+s2;
     
766.                 delay1(5) ;
     
767. 
     
768.                            while(DP==s2)
     
769.                 fk();
     
770.                 s3=DP ;
     
771.                 lcd_pos(2,0);
     
772.                         dis6[9]=(0x30+DP);       
     
773.                 for(i=0;i<15;i++)
     
774.            write_data(dis6[i]);
     
775.            delay1(5) ;
     
776. 
     
777.                    while(DP==s3)
     
778.                 fk();
     
779.                 s4=DP ;
     
780.                 lcd_pos(2,0);
     
781.                         dis6[10]=(0x30+DP);       
     
782.                 for(i=0;i<15;i++)
     
783.            write_data(dis6[i]);
     
784.            s0=s3*10+s4;
     
785.                 delay1(5) ;
     
786. 
     
787. 
     
788. 
     
789.                           }
     
790. if(DP==47)
     
791.         {       
     
792. while(DP==47)
     
793.         fk();
     
794.         k2=DP;       
     
795.                 lcd_pos(3,0);
     
796.          if(k2==1)
     
797.         for(i=0;i<14;i++)
     
798.          write_data(dis9[i]);
     
799.          if(k2==2)
     
800.         for(i=0;i<14;i++)
     
801.          write_data(dis7[i]);
     
802.                  delay1(5) ;}
     
803. 
     
804. if(DP==99)
     
805.         {       
     
806.         while(DP==99)
     
807.         fk();
     
808.         k1=DP;       
     
809.                 lcd_pos(0,0);
     
810.          if(k1==1)
     
811.         for(i=0;i<15;i++)
     
812.          write_data(dis8[i]);
     
813.          if(k1==2)
     
814.         for(i=0;i<15;i++)
     
815.          write_data(dis4[i]);
     
816.                  delay1(5) ;
     
817.                                          }
     
818. 
     
819. 
     
820. fk();
     
821.                           }while(DP!=88);
     
822.           
     
823.    
     
824. 
     
825.                           
     
826.                 }
     
827.                        
     
828. 
     
829. 
     
830. 
     
831. if(dat1>w)
     
832. a=0;
     
833. 
     
834. if(dat1<w0)
     
835. b=0;
     
836. if(dat>70)
     
837. p6=0;
     
838. 
     
839. if(dat2/2>s)
     
840. {c=0;
     
841.   p5=0;}
     
842. 
     
843. aa++;
     
844. 
     
845. if(aa>15)
     
846. {
     
847. 
     
848. if(k1==2)
     
849. {
     
850. 
     
851. 
     
852.    if(dat2/2<s)
     
853.           {if(c==0){
     
854.            ret = send_pdu_message0(pdu_content0);//发送pdu短信
     
855.                                                        
     
856.                                 if(ret == 1)
     
857.                                 {
     
858.                                         LED3 = 0;
     
859.                                         c=1;
     
860.                                 }
     
861.                           
     
862. 
     
863.        
     
864.        
     
865.          }  
     
866.        
     
867.        
     
868.           }
     
869. 
     
870.           
     
871.    if(dat1<w)
     
872. 
     
873.    { if(a==0)
     
874.    { delay1(1000);
     
875.            ret = send_pdu_message1(pdu_content2);//发送pdu短信
     
876.                                                        
     
877.                                 if(ret == 1)
     
878.                                 {
     
879.                                         LED3 = 0;
     
880.                                         a=1;
     
881.                                 }
     
882.                           
     
883.         delay1(1000);
     
884.         LED3=1; }              }
     
885. 
     
886. 
     
887.    if(dat1>w0)
     
888.    {if(b==0){
     
889.            ret = send_pdu_message1(pdu_content1);//发送pdu短信
     
890.                                                        
     
891.                                 if(ret == 1)
     
892.                                 {
     
893.                                         LED3 = 0;
     
894.                                         b=1;
     
895.                                 }
     
896.                           
     
897.         delay1(1000);
     
898.         LED3=1; }            }
     
899. 
     
900.        
     
901. }
     
902. 
     
903.   //自动模式
     
904. if(k1==1)
     
905. {
     
906. if(dat1<w)
     
907. 
     
908.    {   
     
909. 
     
910.     if(a==0)
     
911.         { delay1(3000);
     
912.            ret = send_pdu_message1(pdu_content2);//发送pdu短信
     
913.                                                        
     
914.                                 if(ret == 1)
     
915.                                 {
     
916.                                         LED3 = 0;
     
917.                                         a=1;
     
918.                                 }
     
919.                           
     
920.         delay1(1000);
     
921.         LED3=1; }
     
922.                       }
     
923. 
     
924. 
     
925.    if(dat1>w0)
     
926.    {if(b==0)
     
927.    { delay1(3000);
     
928.            ret = send_pdu_message1(pdu_content1);//发送pdu短信
     
929.                                                        
     
930.                                 if(ret == 1)
     
931.                                 {
     
932.                                         LED3 = 0;
     
933.                                         b=1;
     
934.                                 }
     
935.                           
     
936.         delay1(1000);
     
937.         LED3=1; }            }
     
938.                                           
     
939. 
     
940.    if(dat2<s)
     
941.           {if(c==0)
     
942.           {
     
943.            ret = send_pdu_message0(pdu_content0);//发送pdu短信
     
944.                                                        
     
945.                                 if(ret == 1)
     
946.                                 {
     
947.                                
     
948.                                         c=1;
     
949.                                 }
     
950.                   
     
951.         }  p5=1;  }
     
952. if(k2==1)
     
953. {                                               
     
954. if(dat<70)
     
955. p6=1;                                               
     
956.         }
     
957. if(k2==2)
     
958. {                                               
     
959. p6=0;                                               
     
960.         }               
     
961.        
     
962.                                          }
     
963. 
     
964. 
     
965.                          }
     
966. 
     
967. 
     
968.                 }}
     
969.                        
     
970.                                
     
971. 
     
972. 
     
973. 
     
974. 
     
975. 
     
976. 
     
977. 
     
978. 
     
979. 
     
980. 
     
981. 
     
982. 
     
983. 
     
984. 
     
985. 
     
986. /*******************************************************************************
     
987. * 函数名 : Timer0_ISR
     
988. * 描述   : 定时器0中断服务入口函数,1ms中断一次
     
989. * 输入   :
     
990. * 输出   :
     
991. * 返回   :
     
992. * 注意   :
     
993. *******************************************************************************/
     
994. 
     
995. 
     
996. /********************* UART1中断函数************************/
     
997. void UART1_ISR (void) interrupt 4
     
998. {
     
999.         if (RI)
     
1000.         {
      
1001.                 RI = 0;                           //清除RI位
      
1002.                 Uart1_Buf[First_Int] = SBUF;            //将接收到的字符串存到缓存中
      
1003.                 First_Int++;                          //缓存指针向后移动
      
1004.                 if(First_Int > Buf_Max)                 //如果缓存满,将缓存指针指向缓存的首地址
      
1005.                 {
      
1006.                         First_Int = 0;
      
1007.                 }
      
1008.                 /*
      
1009.                 if(First_Int >=6)
      
1010.                 {
      
1011.                         if(Find("RING"))
      
1012.                         {
      
1013.                                 LED7 = 0;
      
1014.                         }
      
1015.                         else
      
1016.                         {
      
1017.                                 LED7 = 1;
      
1018.                         }
      
1019.                 }
      
1020.                 */
      
1021.                 if(receive_message_mode == 1)//说明进入接收短信的模式,
      
1022.                 {
      
1023.                         if(First_Int >=22)//这里的22是根据情况进行判断设定的
      
1024.                         {
      
1025.                                 ledon_flag = 1;
      
1026.                         }
      
1027.                 }
      
1028.                
      
1029.         }
      
1030.         if (TI)
      
1031.         {
      
1032.                 TI = 0;                          //清除TI位
      
1033.         }
      
1034. }
      
1035. 
      
1036. 
      
1037. /*******************************************************************************
      
1038. * 函数名 : CLR_Buf
      
1039. * 描述   : 清除串口2缓存数据
      
1040. * 输入   :
      
1041. * 输出   :
      
1042. * 返回   :
      
1043. * 注意   :
      
1044. *******************************************************************************/
      
1045. void CLR_Buf(void)
      
1046. {
      
1047.         u8 k;
      
1048.         for(k=0;k<Buf_Max;k++)      //将缓存内容清零
      
1049.         {
      
1050.                 Uart1_Buf[k] = 0x00;
      
1051.         }
      
1052.     First_Int = 0;              //接收字符串的起始存储位置
      
1053. }
      
1054. 
      
1055. 
      
1056. /*******************************************************************************
      
1057. * 函数名 : Find
      
1058. * 描述   : 判断缓存中是否含有指定的字符串
      
1059. * 输入   :
      
1060. * 输出   :
      
1061. * 返回   : unsigned char:1 找到指定字符，0 未找到指定字符
      
1062. * 注意   :
      
1063. *******************************************************************************/
      
1064. 
      
1065. u8 Find(u8 *a)
      
1066. {
      
1067.         ES = 0;  //改进程序
      
1068.         if(strstr(Uart1_Buf,a)!=NULL)
      
1069.         {
      
1070.                 ES = 1;
      
1071.                 return 1;
      
1072.         }       
      
1073.         else
      
1074.         {
      
1075.                 ES = 1;
      
1076.                 return 0;
      
1077.         }
      
1078.                
      
1079. }
      
1080. 
      
1081. 
      
1082. 
      
1083. /*******************************************************************************
      
1084. * 函数名 : Wait_CREG
      
1085. * 描述   : 等待模块注册成功
      
1086. * 输入   :
      
1087. * 输出   :
      
1088. * 返回   :
      
1089. * 注意   :
      
1090. *******************************************************************************/
      
1091. void Wait_CREG(void)
      
1092. {
      
1093.         u8 i;
      
1094.         u8 k;
      
1095.         i = 0;
      
1096.         CLR_Buf();
      
1097.         while(i == 0)                               
      
1098.         {
      
1099. 
      
1100.                 UART1_Send_Command("AT+CREG?");
      
1101.                 delay_ms(100);
      
1102.                
      
1103.                 for(k=0;k<Buf_Max;k++)                             
      
1104.                 {
      
1105.                         if((Uart1_Buf[k] == '+')&&(Uart1_Buf[k+1] == 'C')&&(Uart1_Buf[k+2] == 'R')&&(Uart1_Buf[k+3] == 'E')&&(Uart1_Buf[k+4] == 'G')&&(Uart1_Buf[k+5] == ':'))
      
1106.                         {
      
1107.                                          
      
1108.                                 if((Uart1_Buf[k+7] == '1')&&((Uart1_Buf[k+9] == '1')||(Uart1_Buf[k+9] == '5')))
      
1109.                                 {
      
1110.                                         i = 1;
      
1111.                                         LED1 =0;
      
1112.                                         break;
      
1113.                                 }
      
1114.                                
      
1115.                         }
      
1116.                 }
      
1117.                
      
1118.         }
      
1119. }
      
1120. 
      
1121. 
      
1122. 
      
1123. /*----------------------------
      
1124. UART1 发送串口数据
      
1125. -----------------------------*/
      
1126. void UART1_SendData(u8 dat)
      
1127. {
      
1128.         ES=0;                        //关串口中断
      
1129.         SBUF=dat;                       
      
1130.         while(TI!=1);        //等待发送成功
      
1131.         TI=0;                        //清除发送中断标志
      
1132.         ES=1;                        //开串口中断
      
1133. }
      
1134. /*----------------------------
      
1135. UART1 发送字符串
      
1136. -----------------------------*/
      
1137. void UART1_SendString(char *s)
      
1138. {
      
1139.         while(*s)//检测字符串结束符
      
1140.         {
      
1141.                 UART1_SendData(*s++);//发送当前字符
      
1142.         }
      
1143. }
      
1144. 
      
1145. /**********************************
      
1146. 发送命令
      
1147. **********************************/
      
1148. void UART1_Send_Command(char *s)
      
1149. {
      
1150.         CLR_Buf();
      
1151.         while(*s)//检测字符串结束符
      
1152.         {
      
1153.                 UART1_SendData(*s++);//发送当前字符
      
1154.         }
      
1155.         UART1_SendLR();
      
1156. }
      
1157. 
      
1158. /*******************************************************************************
      
1159. * 函数名 : Second_AT_Command
      
1160. * 描述   : 发送AT指令函数
      
1161. * 输入   : 发送数据的指针、希望收到的应答、发送等待时间(单位：interval_time*20 ms)
      
1162. * 输出   :
      
1163. * 返回   :
      
1164. * 注意   :
      
1165. *******************************************************************************/
      
1166. 
      
1167. u8 UART1_Send_AT_Command(u8 *b,u8 *a,u8 wait_time,u16 interval_time)         
      
1168. {
      
1169.         u8 i;
      
1170. 
      
1171.         CLR_Buf();
      
1172.         i = 0;
      
1173.         while(i < wait_time)                    
      
1174.         {
      
1175.                 UART1_Send_Command(b);
      
1176.                 delay_ms(interval_time);
      
1177.                 if(Find(a))            //查找需要应答的字符
      
1178.                 {
      
1179.                         return 1;
      
1180.                 }
      
1181.                 i++;
      
1182.         }
      
1183.        
      
1184.         return 0;
      
1185. }
      
1186. 
      
1187. void delay_ms(u16 ms)
      
1188. {
      
1189.         u16 i,j;
      
1190.        
      
1191.         for (i=ms*20;i>0;i--)
      
1192.         for (j=110;j>0;j--)        ;
      
1193.        
      
1194. }
      
1195. 
      

复制代码

全部资料下载地址：
智能花盆程序.docx (24.63 KB, 下载次数: 47)

2017-9-1 12:31 上传

点击文件名下载附件
下载积分: 黑币 -5

---

欢迎光临 (http://www.51hei.com/bbs/)

Powered by Discuz! X3.1