设为首页收藏本站
开启辅助访问 切换到宽版

 找回密码
 立即注册

QQ登录

只需一步，快速开始

热门： 51单片机 | 24小时必答区 | 单片机教程 | 单片机DIY制作 | STM32 | Cortex M3 | 模数电子 | 电子DIY制作 | 音响/功放 | 拆机乐园 | Arduino | 嵌入式OS | 程序设计

帖子
»论坛 › 嵌入式/单片机论坛 › 51单片机 › 51单片机gsm-A6+lcd2864智能花盆程序代码
返回列表 发新帖
查看: 4233|回复: 1
打印 上一主题 下一主题
收起左侧

51单片机gsm-A6+lcd2864智能花盆程序代码

[复制链接]
跳转到指定楼层
楼主
ID:225134 发表于 2017-9-1 12:32 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
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

  7. typedef         unsigned char        u8;
  8. typedef         unsigned int        u16;
  9. typedef         unsigned long        u32;


  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指令的间隔时间


  18. //串口1发送回车换行
  19. #define UART1_SendLR() UART1_SendData(0X0D);\
  20.                                                                                          UART1_SendData(0X0A)

  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;


  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;        //红外用全局变量

  48. bit irpro_ok,irok;
  49. unsigned char xdata IRcord[4];
  50. unsigned char xdata irdata[33];

  52. uchar temp1;

  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[]={"补光:       开 "};

  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;

  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);


  88. void adjust_A6_buadrate(void)
  89. {
  90.         u8 ret;

  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. }


  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. }

  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. }

  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. }

  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);


  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. }



  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();

  331.         norespons();
  332.         stop();
  333.         return dat;
  334. }

  336.   
  337. void TempDelay(uchar us)
  338. {
  339.         while(us--); //6.51us
  340. }

  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. }

  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. }



  430. void Ir_work(void);
  431. void Ircordpro(void);

  433. void tim0_isr (void) interrupt 1 using 1
  434. {
  435.   irtime++;  //用于计数2个下降沿之间的时间
  436. }

  438. void EX0_ISR (void) interrupt 0 //外部中断0服务函数
  439. {
  440.         static unsigned char  i;             //接收红外信号处理
  441.         static bit startflag;                //是否开始处理标志位

  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. }

  463. void Uart1Init(void)                //9600bps@11.05926MHz
  464. {
  465.         PCON =0x80;                //
  466.         SCON = 0x50;                //

  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. }


  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. }


  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;

  521.                          }

  523.                   irpro_ok=0;//处理完成标志

  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. }



  551.     void fk()
  552. {if(irok)                       
  553.                 {   
  554.                         Ircordpro();
  555.                         irok=0;
  556.                 }
  557.                 if(irpro_ok)                  
  558.                
  559.         Ir_work();}

  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();



  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"



  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) ;

  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();


  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.                                

  648.                                  
  649.   //控制界面

  651.                      fk();

  653.      if (DP==66)       
  654.          
  655. {          
  656.          

  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) ;

  668.                                                                                                          

  670. lcd_pos(1,0);
  671.                         for(i=0;i<15;i++)
  672.                         {write_data(dis5[i]);         }
  673.                                 delay1(5);

  675. lcd_pos(2,0);
  676.         for(i=0;i<15;i++)
  677.                         {write_data(dis6[i]);         }
  678.                                 delay1(5)  ;


  681. lcd_pos(3,0);
  682.         if(k2==2)        {                                                                  
  683. for(i=0;i<14;i++)
  684.         write_data(dis7[i]);        }

  686. if(k2==1)  {
  687. for(i=0;i<14;i++)               
  688. write_data(dis9[i]);

  690.                                  }
  691.                                 delay1(5) ;


  694.   do{
  695.          do{
  696.       fk();
  697.                         }while(DP==66);
  698.           

  700. if(DP==45)
  701.         {       
  702.         while(DP==45)
  703.         fk();
  704.         w1=DP;       
  705.                 lcd_pos(1,0);

  707.                 dis5[6]=(0x30+DP);       
  708.                 for(i=0;i<15;i++)
  709.            write_data(dis5[i]);
  710.                  delay1(5) ;

  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) ;

  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) ;

  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) ;




  744.                           }
  745.                
  746. if(DP==46)                       
  747.         {       
  748.         while(DP==46)
  749.         fk();
  750.         s1=DP;       
  751.                 lcd_pos(2,0);

  753.                 dis6[6]=(0x30+DP);       
  754.                 for(i=0;i<10;i++)
  755.            write_data(dis6[i]);
  756.                  delay1(5) ;

  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) ;

  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) ;

  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) ;



  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) ;}

  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.                                          }


  820. fk();
  821.                           }while(DP!=88);
  822.           
  823.    

  825.                           
  826.                 }
  827.                        



  831. if(dat1>w)
  832. a=0;

  834. if(dat1<w0)
  835. b=0;
  836. if(dat>70)
  837. p6=0;

  839. if(dat2/2>s)
  840. {c=0;
  841.   p5=0;}

  843. aa++;

  845. if(aa>15)
  846. {

  848. if(k1==2)
  849. {


  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.                           

  863.        
  864.        
  865.          }  
  866.        
  867.        
  868.           }

  870.           
  871.    if(dat1<w)

  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; }              }


  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; }            }

  900.        
  901. }

  903.   //自动模式
  904. if(k1==1)
  905. {
  906. if(dat1<w)

  908.    {   

  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.                       }


  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.                                           

  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.                                          }


  965.                          }


  968.                 }}
  969.                        
  970.                                















  986. /*******************************************************************************
  987. * 函数名 : Timer0_ISR
  988. * 描述   : 定时器0中断服务入口函数,1ms中断一次
  989. * 输入   :
  990. * 输出   :
  991. * 返回   :
  992. * 注意   :
  993. *******************************************************************************/


  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. }


  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. }


  1056. /*******************************************************************************
  1057. * 函数名 : Find
  1058. * 描述   : 判断缓存中是否含有指定的字符串
  1059. * 输入   :
  1060. * 输出   :
  1061. * 返回   : unsigned char:1 找到指定字符，0 未找到指定字符
  1062. * 注意   :
  1063. *******************************************************************************/

  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. }



  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.         {

  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. }



  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. }

  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. }

  1158. /*******************************************************************************
  1159. * 函数名 : Second_AT_Command
  1160. * 描述   : 发送AT指令函数
  1161. * 输入   : 发送数据的指针、希望收到的应答、发送等待时间(单位：interval_time*20 ms)
  1162. * 输出   :
  1163. * 返回   :
  1164. * 注意   :
  1165. *******************************************************************************/

  1167. u8 UART1_Send_AT_Command(u8 *b,u8 *a,u8 wait_time,u16 interval_time)         
  1168. {
  1169.         u8 i;

  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. }

  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. }

复制代码

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


分享到:  QQ好友和群QQ好友和群 QQ空间QQ空间 腾讯微博腾讯微博 腾讯朋友腾讯朋友
收藏收藏1 分享淘帖 顶顶 踩踩
回复

举报

沙发
ID:312293 发表于 2018-4-24 16:48 | 只看该作者
此帖仅作者可见

举报

返回列表 发新帖
高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

小黑屋|51黑电子论坛 |51黑电子论坛6群 QQ 管理员QQ:125739409;技术交流QQ群281945664

Powered by 单片机教程网

快速回复 返回顶部 返回列表