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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › MCU综合技术区 › 完整实际应用NXP modbus编程实例
返回列表 发新帖
查看: 3476|回复: 1
收起左侧

完整实际应用NXP modbus编程实例

[复制链接]
ID:90762 发表于 2018-10-6 15:53 | 显示全部楼层 |阅读模式
完整实际应用NXP modbus编程实例。包括modbus协议，flash 编程
0.png

单片机源程序如下:

  2. #include "config.h"
  3. //                  unsigned int test=1200;
  4. CONFIG_TYPE         sysconfig;         //终端配置信息
  5. unsigned char gSendBuffer[GPRSBUFFERLEN];
  6. char gReceiveBuffer[GPRSBUFFERLEN];
  7. char DomainStr[30];
  8. char DomainStrl;
  9. char MyIPStr[30];
  10. char MyIPStrl;
  11. unsigned long gReceiveBufferLen = 0;
  12. unsigned char gReceiveFlag = 0;

  14. //创建多TCP链路
  15. typedef enum
  16. {        Link0,
  17.     Link1,
  18.     Link2,
  19.     Link3,
  20. }link_enum_type;
  21. void GPRS_OFF(void)
  22. {
  23.         SET_BIT(IODIR1,22);
  24.         SET_BIT(IOSET1,22);          //ON/OFF_GPRS
  25.         SET_BIT(IODIR1,16);
  26.         SET_BIT(IOCLR1,16); //GPRSVCC_EN
  27. }
  28. void GPRS_Init(void)
  29. {
  30.         /******GPRS启动时序******/
  31. //        SET_BIT(IODIR1,22);
  32. //        SET_BIT(IOSET1,22);          //ON/OFF_GPRS
  33. //        SET_BIT(IODIR1,16);
  34. //        SET_BIT(IOCLR1,16); //GPRSVCC_EN
  35.        
  36. //        Gprs_Delayms(5000);
  37.        
  38.         SET_BIT(IOSET1,16);//LPC_GPIO2->SET |= 1UL << 28;
  39.        
  40.         Gprs_Delayms(1000);
  41.        
  42.         SET_BIT(IOCLR1,22);//LPC_GPIO2->SET |= 1UL << 27;
  43.        
  44.         Gprs_Delayms(1000);

  46. }


  49. /*****************************************************
  50.         *函数名称：Gprs_Delayms(unsigned timelen)
  51.           *函数描述：ms级的延迟函数
  52.         *入口参数：需要延迟的时间
  53.         *出口参数：无
  54. *****************************************************/
  55. void Gprs_Delayms(unsigned int timelen)
  56. {  
  57.     unsigned int i,count;
  58.         for(i=0;i<timelen;i++)
  59.         {        count=11460;
  60.                 while(count--);                                        //10000大约1ms
  61.                
  62.         }
  63. }



  67. /***************************************************************************************
  68.           *函数名称：Gprs_CheckPBReady(void)
  69.           *函数描述：检查是否收到+PBReady，只有接收到“+PBREADY”后，才开始对模块进行AT指令操作。
  70.         *入口参数：无
  71.         *出口参数：返回一个bool值
  72. ****************************************************************************************/
  73. bool Gprs_CheckPBReady(void)
  74. {
  75.         int timeout=0;
  76.         do
  77.         {
  78.                 timeout++;
  79.                 if(gReceiveFlag == 1)
  80.         {
  81.                     if(strstr((char *)gReceiveBuffer,"+PBREADY")>0)
  82.                     {
  83.                         //说明收到+PBREADY，退出
  84.                             gReceiveFlag = 0;
  85.                                 gReceiveBufferLen = 0;
  86.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  87.                                 break;
  88.                     }
  89.                     Gprs_Delayms(200);
  90.         }

  92.         }while(timeout<10);
  93.         if(timeout>=10)
  94.         {
  95.                 //报错
  96.                 return false;
  97.         }
  98.         return true;
  99. }

  101. /*****************************************************
  102.           *函数名称：Gprs_CheckCCID(void)          
  103.           *函数描述：检查SIM卡标识信息
  104.         *AT指令：“AT+CCID\r"
  105.         *入口参数：无
  106.         *出口参数：返回一个bool值
  107. *****************************************************/
  108. bool Gprs_CheckCCID(void)
  109. {
  110.         int timeout=0; //超时次数变量
  111.         do
  112.         {
  113.                 timeout++;
  114.             Gprs_SendATCommand("AT+CCID\r",8);  
  115.                 //通过串口发送AT+CCID回车，获取SIM卡标识
  116.                 Gprs_Delayms(200);                         //延时200ms
  117.         if(gReceiveFlag == 1)
  118.         {
  119.                         //判断接受缓冲区是否有数据       
  120.                     if(strstr((char *)gReceiveBuffer,"ERROR")==0)       
  121.                     {
  122.                         //查找完全匹配的子字符串，说明返回值不是ERROR，表示读取sim卡的CCID成功，退出  
  123.                             gReceiveFlag = 0;
  124.                                 gReceiveBufferLen = 0;
  125.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  126.                                 break;
  127.                     }
  128.         }       
  129.         }while(timeout<10);         
  130.         if(timeout>10)
  131.         {
  132.                 //报错
  133.                 return false;
  134.         }
  135.          return true;
  136. }





  142. /***************************************************************************************
  143.           *函数名称：Gprs_CheckAT(void)
  144.           *函数描述：检查串口是否通，收到OK，则说明串口已接通
  145.         *AT指令：“AT\r"
  146.         *入口参数：无
  147.         *出口参数：返回一个bool值
  148. ****************************************************************************************/
  149. bool Gprs_CheckAT(void)
  150. {
  151.         int timeout=0;
  152. //        char str[35];
  153.         do
  154.         {
  155.                 timeout++;
  156.                 Gprs_SendATCommand("AT\r",3);         //通过串口发送AT回车
  157.                 Gprs_Delayms(100);
  158.                  if(gReceiveFlag == 1)
  159.          {
  160.                           //UART0_snd((unsigned char *)gReceiveBuffer,gReceiveBufferLen);
  161.                      if(strstr((char *)gReceiveBuffer,"OK")>0)
  162.                      {
  163.                      //说明串口通，退出
  164.                              gReceiveFlag = 0;
  165.                                  gReceiveBufferLen = 0;
  166.                                  memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  167.                                  break;
  168.                     }
  169.          }
  170.         }while(timeout<10);
  171.          if(timeout>=10)
  172.         {
  173.         //报错

  175. //        test+=100;
  176. //        sprintf(str,"%d",test);
  177. //        UART0_snd(str,sizeof(str));
  178. // UART1_init(60000000, test);
  179.          return false;
  180.         }
  181.         return true;
  182. }


  185. /***************************************************************************************
  186.           *函数名称：Gprs_CheckCSQ(void)
  187.           *函数描述：检查信号强度，回显值：+CSQ：<rssi>,<ber>,其中rssi为查询接受信号
  188.                                 强度，值在0~31之间，值越大表示强度越强，若为99，则说明未知或不可检测；ber为信道
  189.                                 位错误率，值在0~7，若为99，则说明未知或不可检测
  190.         *AT指令：“AT+CSQ\r"
  191.         *入口参数：无
  192.         *出口参数：返回一个bool值
  193. ****************************************************************************************/
  194. bool Gprs_CheckCSQ(void)
  195. {
  196.         char *buf;
  197.        
  198.         int timeout=0;
  199.         do
  200.         {
  201.                 timeout++;
  202.                 Gprs_SendATCommand("AT+CSQ\r",7);        //检查信号强度
  203.                 Gprs_Delayms(100);
  204.                 if(gReceiveFlag == 1)
  205.         {
  206.                     if(strstr(gReceiveBuffer,"+CSQ: 99,99")==0)
  207.                     {
  208.                                 //说明检查的不是99,99，有信号，退出
  209.                                 buf =strstr(gReceiveBuffer,"+CSQ:");
  210.                                 if(sysconfig.Tishi ==0) UART0_snd("Signal: ",8);
  211.                                 if(sysconfig.Tishi ==0) UART0_snd((unsigned char*)&buf[6],2);
  212.                                 if(sysconfig.Tishi ==0) UART0_snd("\r\n",2);
  213.                             gReceiveFlag = 0;
  214.                                 gReceiveBufferLen = 0;
  215.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  216.                                 break;
  217.                         }
  218.         }
  219.         }while(timeout<10);
  220.          if(timeout>=10)
  221.          {
  222.                  return false;
  223.          }
  224.          return true;
  225. }


  228. /***************************************************************************************
  229.           *函数名称：Gprs_CheckCREG(void)
  230.           *函数描述：检查模块当前的网络注册状态，只有当回显值为0,1或0,5时，才表示网络注册成功
  231.         *AT指令："AT+CREG?\r"
  232.         *入口参数：无
  233.         *出口参数：返回一个bool值
  234. ****************************************************************************************/
  235. bool Gprs_CheckCREG(void)
  236. {
  237.     int timeout;  // 超时次数变量；           
  238.         timeout = 0;
  239.         do
  240.     {   
  241.             timeout++;
  242.                 Gprs_SendATCommand("AT+CREG?\r",9);
  243.                 // 通过串口发送AT+CREG?回车,查询模块的当前网络注册状态       
  244.                 Gprs_Delayms(100);                         
  245.                 if(gReceiveFlag == 1)
  246.         {       
  247.                      
  248.                         if(strstr((char *)gReceiveBuffer,"+CREG: 0,1")>0 ||strstr((char *)gReceiveBuffer,"+CREG: 0,5")>0)//||strstr((char *)gReceiveBuffer,"OK")>0)
  249.                     {
  250.                                 // 如果返回值为+CREG: 0,1或+CREG: 0,5，则网络注册成功
  251.                 gReceiveFlag =0;
  252.                                 gReceiveBufferLen = 0;
  253.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  254.                                 break;
  255.                         }
  256.         }
  257.         }while(timeout<10);         
  258.         if( timeout>=10 )
  259.         {
  260.                 // 报错；说明网络注册失败！
  261.                 return false;
  262.         }       
  263.         return true;
  264. }

  266. /***************************************************************************************
  267.           *函数名称：Gprs_SetStack(void)
  268.           *函数描述：设置
  269.         *AT指令："AT+CREG?\r"
  270.         *入口参数：无
  271.         *出口参数：返回一个bool值
  272. ****************************************************************************************/
  273. bool Gprs_SetStack(void)
  274. {
  275.     int timeout;  // 超时次数变量；           
  276.         timeout = 0;
  277.         do
  278.     {   
  279.             timeout++;
  280.                 Gprs_SendATCommand("AT+_XISP=0\r",10); //使用内部协议栈
  281.                 // 通过串口发送AT+CREG?回车,查询模块的当前网络注册状态       
  282.                 Gprs_Delayms(100);                               
  283.                 if(gReceiveFlag == 1)
  284.         {               
  285.                     if( strstr((char *)gReceiveBuffer,"OK")>0 )
  286.                     {
  287.                                 // 如果返回值为+CREG: 0,1或+CREG: 0,5，则网络注册成功
  288.                 gReceiveFlag =0;
  289.                                 gReceiveBufferLen = 0;
  290.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  291.                                 break;
  292.                         }
  293.         }
  294.         }while(timeout<10);         
  295.         if( timeout>=10 )
  296.         {
  297.                 // 报错；说明网络注册失败！
  298.                 return false;
  299.         }       
  300.         return true;
  301. }
  302. /***************************************************************************************
  303.           *函数名称：Gprs_CheckPPPLink(void)
  304.           *函数描述：建立PPP链接，
  305.         *AT指令：”AT+XIIC=1\r“
  306.         *入口参数：无
  307.         *出口参数：返回一个bool值
  308.         *注：1.在建立PPP链路之前，先要使用AT+CGDCONT设定APN等参数
  309.                  2.设置AT+CGDCONT之前要先设置AT+XISP=0，即选择内部协议栈
  310.                  3.在使用AT+XIIC=1建立PPP连接之前，先要确保模块已经注册上网络。可使用
  311.                    AT+CREG?来判断，如果返回+CREG：0,1或+CREG：0,5，都表明已注册上网络。
  312. ****************************************************************************************/
  313. bool Gprs_CreatePPPLink(void)
  314. {
  315.                 int timeout;  // 超时次数变量；       
  316.                 timeout = 0;
  317.                 do
  318.                 {  
  319.                         timeout++;
  320.                         Gprs_SendATCommand("AT+XIIC=1\r",10);        //要求建立PPP连接
  321.                     Gprs_Delayms(100);                  // 延时100ms       
  322.                         if(gReceiveFlag == 1)
  323.             {                       
  324.                             if( strstr((char *)gReceiveBuffer,"OK")>0 )
  325.                             {
  326.                                         // 如返回OK 跳出循环
  327.                                     gReceiveFlag = 0;
  328.                                         gReceiveBufferLen = 0;
  329.                                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  330.                                         break;
  331.                             }
  332.             }
  333.                 }while(timeout<10);                 
  334.             if( timeout>=10 )
  335.                 {
  336.                         // 报错；说明PPP建立失败！
  337.                         return false;
  338.                 }
  339.                 return true;
  340.         }


  343. /***************************************************************************************
  344.           *函数名称：Gprs_CheckPPPStatus(void)
  345.           *函数描述：查询PPP链路状态
  346.         *AT指令："AT+XIIC=?\r"
  347.         *入口参数：无
  348.         *出口参数：返回一个bool值
  349. ****************************************************************************************/
  350. bool Gprs_CheckPPPStatus(void)
  351. {
  352.     int value=0;  // 超时次数变量；  
  353.         char *pstr1,*pstr2;         
  354.         do
  355.         {   
  356.                 value++;               
  357.             Gprs_SendATCommand("AT+XIIC?\r",9);
  358.                 //发送AT+XIIC=?查询链路状态
  359.             Gprs_Delayms(500);   // 延时500ms;               
  360.                 if(gReceiveFlag == 1)
  361.         {                                               
  362.                        if( strstr((char *)gReceiveBuffer,"+XIIC:    1")>0 )
  363. //                                if(strstr((char *)gReceiveBuffer,"OK")>0)
  364.                     {
  365.                         //判断返回值 如果返回+XIIC:    1, *.*.*.*,则跳出循环，1前面有4个空格                               
  366.                             //result_ok = true;
  367.                                 pstr1=strstr((char *)gReceiveBuffer,"1,");
  368.                                 pstr2=strstr((char *)pstr1,"\r\n");
  369.                                 if((pstr2>pstr1)&&pstr1!=0) MyIPStrl=(pstr2-pstr1)-3;
  370.                                 else return false;
  371.                                 memcpy(MyIPStr,pstr1+3,MyIPStrl);
  372.                                 gReceiveFlag = 0;
  373.                                 gReceiveBufferLen = 0;
  374.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  375.                                 if(sysconfig.Tishi ==0) UART0_snd("PPP Link OK\r\n",13);
  376.                                 if(sysconfig.Tishi ==0) UART0_snd("IP: ",4);
  377.                                 if(sysconfig.Tishi ==0) UART0_snd((unsigned char*)MyIPStr,MyIPStrl);
  378.                                 if(sysconfig.Tishi ==0) UART0_snd("\r\n",2);
  379.                                 break;
  380.                     }
  381.                     gReceiveFlag = 0;
  382.                                 gReceiveBufferLen = 0;
  383.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  384.         }
  385.         }while(value<5);          
  386.         if( value>=5 )
  387.         {
  388.                 // 报错；说明PPP建立失败！
  389.                 return false;
  390.         }
  391.         return true;
  392. }
  393. bool Search_IP(void)
  394. {
  395.         char buffer[50];
  396.         unsigned char i,len;
  397.         char *pstr1,*pstr2;
  398.         int value=0;  // 超时次数变量；
  399.         sprintf(buffer,"AT+DNS=");
  400.         buffer[7]=0x22;
  401.         for(i=8;i<sysconfig.gprs_station.lDomainName+8;i++) buffer[i]=sysconfig.gprs_station.DomainName[i-8];
  402.         buffer[i]=0x22;
  403.         len=i+1;
  404.         buffer[len]='\r';
  405.         len++;
  406.         Gprs_SendATCommand(buffer,len);//发送查询链路状态
  407.         do
  408.         {   
  409.                 value++;               
  410.            
  411.                
  412.             Gprs_Delayms(1000);   // 延时500ms;               
  413.                 if(gReceiveFlag == 1)
  414.         {   pstr2=strstr((char *)gReceiveBuffer,"+DNS:OK");
  415.                         pstr1=strstr((char *)gReceiveBuffer,"+DNS:");                                          
  416.                        if( (pstr2!=NULL)&&(pstr1!=NULL)&&(pstr2>pstr1) )
  417. //                                if(strstr((char *)gReceiveBuffer,"OK")>0)
  418.                     {
  419.                         //判断返回值 如果返回+XIIC:    1, *.*.*.*,则跳出循环，1前面有4个空格                               

  421.                                 DomainStrl=pstr2-pstr1;
  422.                                 DomainStrl-=7;
  423.                                 memcpy(DomainStr,pstr1+5,DomainStrl);
  424.                                 sprintf(&DomainStr[DomainStrl],",%d\r",sysconfig.gprs_station.Cport);
  425.                                 DomainStrl+=3;
  426.                                 gReceiveFlag = 0;
  427.                                 gReceiveBufferLen = 0;
  428.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  429.                                 break;
  430.                     }
  431.             //        gReceiveFlag = 0;
  432.                         //        gReceiveBufferLen = 0;
  433.                         //        memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  434.         }
  435.         }while(value<5);          
  436.         if( value>=5 )
  437.         {        if(sysconfig.Tishi ==0)  UART0_snd("Get IP By Domain Name False.\r\n",30);
  438.                 Reset();// 报错；说明PPP建立失败！
  439.                 return false;
  440.         }
  441.         return true;
  442. }
  443. /********************************************************************************
  444.    *函数名称：Gprs_CreateTCPLink(unsigned char *linkStr,int size)
  445.    *函数功能：建立TCP链接
  446.    *AT指令：AT+TCPSETUP=<n>,<ip>,<port>
  447.                            其中n为链路编号0和1；ip为目的IP地址，必须是形如XX.XX.XX.XX的输入；
  448.                         port为目的端口号，必须是十进制的ASCII码
  449.    *入口参数：所需发送的TCP指令 AT+TCPSETUP=<n>,<ip>,<port>,即包括所有信息的字符串
  450.    *出口参数：返回一个bool值
  451. **********************************************************************************/
  452. bool Gprs_CreateTCPLink(char *linkStr,int size)
  453. {
  454.     int timeout;  // 超时次数变量；
  455.         if( size<=0 )        
  456.         return false;
  457.         timeout = 0;
  458.         Gprs_SendATCommand(linkStr,size);//发送AT指令建立TCP连接               
  459.         Gprs_Delayms(500);   // 延时500ms;
  460.         do
  461.         {
  462.                 timeout++;
  463.                 Gprs_Delayms(100);   // 延时10ms;
  464.                 if(gReceiveFlag == 1)
  465.         {
  466.                     if( strstr((char *)gReceiveBuffer,"+TCPSETUP:0,OK")>0 )
  467.                     {
  468.                                 //判断返回值 如果返回+TCPSETUP:0,OK,则跳出循环                   
  469.                             gReceiveFlag = 0;
  470.                                 gReceiveBufferLen = 0;
  471.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  472.                                 break;
  473.                     }
  474.         }
  475.         }while(timeout<10);       
  476.         if( timeout>=10 )
  477.         {
  478.                 // 报错；说明TCP链接失败！
  479.                 return false;
  480.         }       
  481.         return true;
  482. }
  483. bool Gprs_CreateUDPLink(char *linkStr,int size)
  484. {
  485.     int timeout;  // 超时次数变量；
  486.         if( size<=0 )        
  487.         return false;
  488.         timeout = 0;
  489.         Gprs_SendATCommand(linkStr,size);//发送AT指令建立TCP连接               
  490.         Gprs_Delayms(500);   // 延时500ms;
  491.         do
  492.         {
  493.                 timeout++;
  494.                 Gprs_Delayms(100);   // 延时10ms;
  495.                 if(gReceiveFlag == 1)
  496.         {
  497.                     if( strstr((char *)gReceiveBuffer,"+UDPSETUP:1,OK")>0 )
  498.                     {
  499.                                 //判断返回值 如果返回+UDPSETUP:1,OK,则跳出循环                   
  500.                             gReceiveFlag = 0;
  501.                                 gReceiveBufferLen = 0;
  502.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  503.                                 break;
  504.                     }
  505.         }
  506.         }while(timeout<10);       
  507.         if( timeout>=10 )
  508.         {
  509.                 // 报错；说明UDP链接失败！
  510.                 return false;
  511.         }       
  512.         return true;
  513. }

  515. /***************************************************************************************
  516.           *函数名称：Gprs_CloseTCPLink(void)
  517.           *函数描述：关闭TCP链路
  518.         *AT指令：AT+TCPCLOSE=<n> 其中的n为链路号
  519.         *入口参数：无
  520.         *出口参数：返回一个bool值
  521. ****************************************************************************************/
  522. bool Gprs_CloseTCPLink(void)
  523. {
  524.         Gprs_SendATCommand("AT+TCPCLOSE=0\r",14);// 发送AT+TCPCLOSE=0回车
  525.     Gprs_Delayms(300);
  526.         return true;
  527. }
  528. bool Gprs_CloseUDPLink(void)
  529. {
  530.         Gprs_SendATCommand("AT+UDPCLOSE=0\r",14);// 发送AT+UDPCLOSE=0回车
  531.     Gprs_Delayms(300);
  532.         return true;
  533. }

  535. /***************************************************************************************
  536.           *函数名称：Gprs_TCP_SendData(void)
  537.           *函数描述：发送TCP数据，这条命令发送完毕后，会接收到大于号">"，这时候请延迟50ms~100ms,
  538.                                 然后发送数据
  539.         *AT指令：AT+TCPSEND=<n>,<length> 其中n为链路编号 length为要发送的数据长度，以字节为单位
  540.                  取值范围1~200
  541.         *入口参数：无
  542.         *出口参数：返回一个bool值
  543. ****************************************************************************************/
  544. bool         Gprs_TCP_SendData(unsigned char *databuf,int size)
  545. {
  546.         int timeout=0;
  547.     char sendtemp[20];

  549.         // 发送数据之前先使用AT+IPSTATUS查看可用 buffer的大小
  550.         do
  551.         {
  552.                 timeout++;
  553.                 Gprs_SendATCommand("AT+IPSTATUS=0\r",14);//发送AT+IPSTATUS=0回车查询TCP链路状态
  554.                 Gprs_Delayms(300);       
  555.                 if(gReceiveFlag == 1)
  556.         {
  557.                     if( strstr((char *)gReceiveBuffer,"+IPSTATUS:0,CONNECT,TCP")>0 )
  558.                     {
  559.                         //链路0建立连接
  560.                 gReceiveFlag =0;
  561.                                 gReceiveBufferLen = 0;
  562.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  563.                             break;
  564.                     }
  565.                     if( strstr((char *)gReceiveBuffer,"+IPSTATUS:0,DISCONNECT")>0 )
  566.                     {
  567.                             // 报错；说明链路没有建立；
  568.                                 #ifdef DEBUG
  569.                                 UART0_snd("+IPSTATUS:0,DISCONNECT,TCP\r\n",28);
  570.                                 #endif
  571.                                 Reset();
  572.                     }
  573.             gReceiveFlag =0;
  574.                         gReceiveBufferLen = 0;
  575.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  576.         }
  577.         }while(timeout<10);                
  578.         if( timeout>=10 )
  579.         {
  580.                 // 报错；说明TCP链接失败！
  581.                 return false;
  582.         }

  584.         // 如果TCP状态OK 则开始发送TCP指令；
  585.         if(size<10)
  586.         {
  587.                 sprintf(sendtemp,"AT+TCPSEND=0,%1d\r",size);
  588.                 Gprs_SendATCommand(sendtemp,15);        //发送 AT+TCPSEND=0,size回车，发送size个字节；
  589.         }
  590.     if((size<100)&&(size>10))
  591.     {
  592.         sprintf(sendtemp,"AT+TCPSEND=0,%2d\r",size);
  593.                 Gprs_SendATCommand(sendtemp,16);        //发送 AT+TCPSEND=0,size回车，发送size个字节；
  594.     }
  595.     else if((size>=100)&&(size<1000))
  596.     {
  597.         sprintf(sendtemp,"AT+TCPSEND=0,%3d\r",size);
  598.                 Gprs_SendATCommand(sendtemp,17);        //发送 AT+TCPSEND=0,size回车，发送size个字节；            
  599.     }
  600.         else if(size>=1000)
  601.         {
  602.            sprintf(sendtemp,"AT+TCPSEND=0,%4d\r",size);
  603.                 Gprs_SendATCommand(sendtemp,18);
  604.         }
  605.         // 判断接收发送符：">"
  606.         do
  607.         {
  608.                 timeout++;
  609.                 Gprs_Delayms(150);   // 延时100ms;
  610.                 if(gReceiveFlag == 1)
  611.         {
  612.                         if( strstr((char *)gReceiveBuffer,">")>0 )
  613.                         {
  614.                                    //判断返回值 如果返回>,则跳出循环，表示可以发送数据了；
  615.                                 gReceiveFlag = 0;
  616.                                 gReceiveBufferLen = 0;
  617.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  618.                                 break;
  619.                         }
  620.         }
  621.         }while(timeout<10);       
  622.         if( timeout>=10 )
  623.         {
  624.                 // 报错；说明没有收到 >,不能发送数据！
  625.                 return false;
  626.         }
  627.         memcpy(gSendBuffer,databuf,size);
  628.         // 开始发送数据；发送数据时，必须在数据包的末尾加上0x0d 作为结束符，但该结束符不算到数据长度里，
  629.     gSendBuffer[size+1] = 0x0D;
  630.         UART1_snd(gSendBuffer,size+1); //发送size个字节数据和回车；记住数据最后要加回车符；
  631.         Gprs_Delayms(200);   // 延时100ms;
  632.         if(gReceiveFlag == 1)
  633.     {
  634.                 if( strstr((char *)gReceiveBuffer,"+TCPSEND:0,")>0 )
  635.                 {
  636.                         // 判断返回值 如果返回+TCPSEND:0,50;表示发送成功；
  637.             gReceiveFlag =0;
  638.                         gReceiveBufferLen = 0;
  639.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  640.                         return true;
  641.                 }
  642.                 else if( strstr((char *)gReceiveBuffer,"+TCPSEND:Error")>0 )
  643.                 {
  644.                 // 判断返回值 如果返回+TCPSEND:Error;在链路0 上发送50字节的数据，该链路尚未建立，发送失败。
  645.                         gReceiveFlag =0;
  646.                         gReceiveBufferLen = 0;
  647.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  648.             return false;
  649.                 }
  650.                 else if( strstr((char *)gReceiveBuffer,"+TCPSEND:Buffer not enough")>0 )
  651.                 {
  652.                         // 判断返回值 如果返回+TCPSEND:Buffer not enough;在链路0 上发送50字节的数据，内部buffer不足，发送失败。
  653.             gReceiveFlag =0;
  654.                         gReceiveBufferLen = 0;
  655.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  656.                         return false;
  657.                 }
  658.     }
  659.         return true;
  660.         // 根据情况加上相应的代码进行处理  ....
  661. }
  662. bool         Gprs_UDP_SendData(unsigned char *databuf,int size)
  663. {
  664.         int timeout=0;
  665.     char sendtemp[20];

  667.         // 发送数据之前先使用AT+IPSTATUS查看可用 buffer的大小
  668.         do
  669.         {
  670.                 timeout++;
  671.                 Gprs_SendATCommand("AT+IPSTATUS=1\r",14);//发送AT+IPSTATUS=0回车查询TCP链路状态
  672.                 Gprs_Delayms(300);       
  673.                 if(gReceiveFlag == 1)
  674.         {
  675.                     if( strstr((char *)gReceiveBuffer,"+IPSTATUS:1,CONNECT,UDP")>0 )
  676.                     {
  677.                         //链路0建立连接
  678.                 gReceiveFlag =0;
  679.                                 gReceiveBufferLen = 0;
  680.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  681.                             break;
  682.                     }
  683.                     if( strstr((char *)gReceiveBuffer,"+IPSTATUS:1,DISCONNECT")>0 )
  684.                     {
  685.                             // 报错；说明链路没有建立；
  686.                                 #ifdef DEBUG
  687.                                 UART0_snd("+IPSTATUS:1,DISCONNECT,UDP\r\n",28);
  688.                                 #endif
  689.                                 Reset();
  690.                     }
  691.             gReceiveFlag =0;
  692.                         gReceiveBufferLen = 0;
  693.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  694.         }
  695.         }while(timeout<10);                
  696.         if( timeout>=10 )
  697.         {
  698.                 // 报错；说明TCP链接失败！
  699.                 return false;
  700.         }

  702.         // 如果TCP状态OK 则开始发送TCP指令；
  703.         if(size<10)
  704.         {
  705.                 sprintf(sendtemp,"AT+UDPSEND=1,%1d\r",size);
  706.                 Gprs_SendATCommand(sendtemp,15);        //发送 AT+TCPSEND=0,size回车，发送size个字节；
  707.         }
  708.     if((size<100)&&(size>10))
  709.     {
  710.         sprintf(sendtemp,"AT+UDPSEND=1,%2d\r",size);
  711.                 Gprs_SendATCommand(sendtemp,16);        //发送 AT+TCPSEND=0,size回车，发送size个字节；
  712.     }
  713.     else if((size>=100)&&(size<1000))
  714.     {
  715.         sprintf(sendtemp,"AT+UDPSEND=1,%3d\r",size);
  716.                 Gprs_SendATCommand(sendtemp,17);        //发送 AT+TCPSEND=0,size回车，发送size个字节；            
  717.     }
  718.         else if(size>=1000)
  719.         {
  720.            sprintf(sendtemp,"AT+UDPSEND=1,%4d\r",size);
  721.                 Gprs_SendATCommand(sendtemp,18);
  722.         }
  723.         // 判断接收发送符：">"
  724.         do
  725.         {
  726.                 timeout++;
  727.                 Gprs_Delayms(150);   // 延时100ms;
  728.                 if(gReceiveFlag == 1)
  729.         {
  730.                         if( strstr((char *)gReceiveBuffer,">")>0 )
  731.                         {
  732.                                    //判断返回值 如果返回>,则跳出循环，表示可以发送数据了；
  733.                                 gReceiveFlag = 0;
  734.                                 gReceiveBufferLen = 0;
  735.                                 memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  736.                                 break;
  737.                         }
  738.         }
  739.         }while(timeout<10);       
  740.         if( timeout>=10 )
  741.         {
  742.                 // 报错；说明没有收到 >,不能发送数据！
  743.                 return false;
  744.         }
  745.         memcpy(gSendBuffer,databuf,size);
  746.         // 开始发送数据；发送数据时，必须在数据包的末尾加上0x0d 作为结束符，但该结束符不算到数据长度里，
  747.     gSendBuffer[size+1] = 0x0D;
  748.         UART1_snd(gSendBuffer,size+1); //发送size个字节数据和回车；记住数据最后要加回车符；
  749.         Gprs_Delayms(200);   // 延时100ms;
  750.         if(gReceiveFlag == 1)
  751.     {
  752.                 if( strstr((char *)gReceiveBuffer,"+UDPSEND:0,")>0 )
  753.                 {
  754.                         // 判断返回值 如果返回+TCPSEND:0,50;表示发送成功；
  755.             gReceiveFlag =0;
  756.                         gReceiveBufferLen = 0;
  757.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  758.                         return true;
  759.                 }
  760.                 else if( strstr((char *)gReceiveBuffer,"+UDPSEND:Error")>0 )
  761.                 {
  762.                 // 判断返回值 如果返回+TCPSEND:Error;在链路0 上发送50字节的数据，该链路尚未建立，发送失败。
  763.                         gReceiveFlag =0;
  764.                         gReceiveBufferLen = 0;
  765.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  766.             return false;
  767.                 }
  768.                 else if( strstr((char *)gReceiveBuffer,"+UDPSEND:Buffer not enough")>0 )
  769.                 {
  770.                         // 判断返回值 如果返回+TCPSEND:Buffer not enough;在链路0 上发送50字节的数据，内部buffer不足，发送失败。
  771.             gReceiveFlag =0;
  772.                         gReceiveBufferLen = 0;
  773.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  774.                         return false;
  775.                 }
  776.     }
  777.         return true;
  778.         // 根据情况加上相应的代码进行处理  ....
  779. }

  781. /***************************************************************************************
  782.           *函数名称：Gprs_TCP_ReceiveData(void)
  783.           *函数描述：接收TCP数据
  784.         *入口参数：无
  785.         *出口参数：返回一个bool值
  786. ****************************************************************************************/
  787. bool Gprs_TCP_ReceiveData(void)
  788. {
  789.     unsigned long recvlen;
  790.     unsigned char i;
  791.    
  792.     Gprs_Delayms(500);
  793.         if(gReceiveFlag == 1)
  794.     {
  795.                 if( strstr((char *)gReceiveBuffer,"+TCPRECV:0")>0 )
  796.                 {// 如果返回+TCPRECV:0
  797.                         // 解析后面的长度和数据；在这里加上代码；
  798.             if(gReceiveBuffer[12] == 0x2C)
  799.             {               
  800.                 for(i=0;i<4;i++)
  801.                 {
  802.                     if(gReceiveBuffer[13+i] == 0x2C) break;   
  803.                 }
  804.                 if(i==4)
  805.                 {
  806.                     goto rcverr;   
  807.                 }
  808.                                 if(i==1)
  809.                 {
  810.                     recvlen = (gReceiveBuffer[13]-0x30);
  811.                     if(recvlen > GPRSBUFFERLEN)
  812.                     {
  813.                         goto rcverr;
  814.                     }
  815.                                 AppDataGprsRcv((unsigned char *)&gReceiveBuffer[15], recvlen);   
  816.                 }
  817.                 if(i==2)
  818.                 {
  819.                     recvlen = (gReceiveBuffer[13]-0x30)*10+(gReceiveBuffer[14]-0x30);
  820.                     if(recvlen > GPRSBUFFERLEN)
  821.                     {
  822.                         goto rcverr;
  823.                     }
  824.                                 AppDataGprsRcv((unsigned char *)gReceiveBuffer+16, recvlen);   
  825.                 }
  826.                 if(i==3)
  827.                 {
  828.                     recvlen = (gReceiveBuffer[13]-0x30)*100+(gReceiveBuffer[14]-0x30)*10+(gReceiveBuffer[15]-0x30);
  829.                     if(recvlen > GPRSBUFFERLEN)
  830.                     {
  831.                         goto rcverr;
  832.                     }
  833.                                 AppDataGprsRcv((unsigned char *)gReceiveBuffer+17, recvlen);   
  834.                 }
  835.             }
  836.             else
  837.             {
  838. rcverr:         gReceiveFlag = 0;
  839.                             gReceiveBufferLen = 0;
  840.                             memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  841.                 return false;   
  842.             }
  843.             gReceiveFlag = 0;
  844.                         gReceiveBufferLen = 0;
  845.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);         
  846.                         return true;
  847.                 }
  848.     }
  849.         gReceiveFlag = 0;
  850.     gReceiveBufferLen = 0;
  851.     memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  852.         return false;
  853. }
  854. bool Gprs_UDP_ReceiveData(void)
  855. {
  856.     unsigned long recvlen;
  857.     unsigned char i;
  858.    
  859.     Gprs_Delayms(500);
  860.         if(gReceiveFlag == 1)
  861.     {
  862.                 if( strstr((char *)gReceiveBuffer,"+UDPRECV:1")>0 )
  863.                 {// 如果返回+TCPRECV:0
  864.                         // 解析后面的长度和数据；在这里加上代码；
  865.             if(gReceiveBuffer[12] == 0x2C)
  866.             {               
  867.                 for(i=0;i<4;i++)
  868.                 {
  869.                     if(gReceiveBuffer[13+i] == 0x2C) break;   
  870.                 }
  871.                 if(i==4)
  872.                 {
  873.                     goto rcverr;   
  874.                 }
  875.                                 if(i==1)
  876.                 {
  877.                     recvlen = (gReceiveBuffer[13]-0x30);
  878.                     if(recvlen > GPRSBUFFERLEN)
  879.                     {
  880.                         goto rcverr;
  881.                     }
  882.                                 AppDataGprsRcv((unsigned char *)&gReceiveBuffer[15], recvlen);   
  883.                 }
  884.                 if(i==2)
  885.                 {
  886.                     recvlen = (gReceiveBuffer[13]-0x30)*10+(gReceiveBuffer[14]-0x30);
  887.                     if(recvlen > GPRSBUFFERLEN)
  888.                     {
  889.                         goto rcverr;
  890.                     }
  891.                                 AppDataGprsRcv((unsigned char *)gReceiveBuffer+16, recvlen);   
  892.                 }
  893.                 if(i==3)
  894.                 {
  895.                     recvlen = (gReceiveBuffer[13]-0x30)*100+(gReceiveBuffer[14]-0x30)*10+(gReceiveBuffer[15]-0x30);
  896.                     if(recvlen > GPRSBUFFERLEN)
  897.                     {
  898.                         goto rcverr;
  899.                     }
  900.                                 AppDataGprsRcv((unsigned char *)gReceiveBuffer+17, recvlen);   
  901.                 }
  902.             }
  903.             else
  904.             {
  905. rcverr:         gReceiveFlag = 0;
  906.                             gReceiveBufferLen = 0;
  907.                             memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  908.                 return false;   
  909.             }
  910.             gReceiveFlag = 0;
  911.                         gReceiveBufferLen = 0;
  912.                         memset(gReceiveBuffer,0,GPRSBUFFERLEN);         
  913.                         return true;
  914.                 }
  915.     }
  916.         gReceiveFlag = 0;
  917.     gReceiveBufferLen = 0;
  918.     memset(gReceiveBuffer,0,GPRSBUFFERLEN);
  919.         return false;
  920. }
  921. /***************************************************************************************
  922.           *函数名称：Gprs_SingleTCPLink(unsigned char iLinkNum,char *strServerIP,char *strPort)
  923.           *函数描述：创建单TCP链路
  924.         *AT指令：AT+TCPSETUP=<n>,<ip>,<port>
  925.         *入口参数：无
  926.         *出口参数：返回一个bool值
  927. ****************************************************************************************/
  928. bool Gprs_SingleTCPLink(unsigned char iLinkNum,unsigned char *strServerIP,unsigned short strPort)
  929. {
  930.         unsigned int length;
  931.     char buffer[50];       
  932.         memset(buffer,0x00,sizeof(buffer));
  933.         sprintf(buffer,"AT+TCPSETUP=%d,%d.%d.%d.%d,%d\r",iLinkNum,
  934.                                                      strServerIP[0],
  935.                                                      strServerIP[1],
  936.                                                      strServerIP[2],
  937.                                                      strServerIP[3],
  938.                                                      strPort);
  939.         length = strlen((char *)buffer);
  940.         if( !Gprs_CreateTCPLink(buffer,length) )  
  941.         {
  942.                 return false;// 建立TCP连接失败；
  943.         }
  944.         return true;
  945. }
  946. bool Gprs_SingleUDPLink(unsigned char iLinkNum,unsigned char *strServerIP,unsigned short strPort)
  947. {
  948.         unsigned int length;
  949.     char buffer[50];       
  950.         memset(buffer,0x00,sizeof(buffer));
  951.         sprintf(buffer,"AT+UDPSETUP=%d,%d.%d.%d.%d,%d\r",iLinkNum,
  952.                                                      strServerIP[0],
  953.                                                      strServerIP[1],
  954.                                                      strServerIP[2],
  955.                                                      strServerIP[3],
  956.                                                      strPort);
  957.         length = strlen((char *)buffer);
  958.         if( !Gprs_CreateUDPLink(buffer,length) )  
  959.         {
  960.                 return false;// 建立TCP连接失败；
  961.         }
  962.         return true;
  963. }
  964. bool Gprs_DomainTCPLink(unsigned char iLinkNum)
  965. {
  966.         unsigned int length;
  967.     char buffer[50];       
  968.         memset(buffer,0x00,sizeof(buffer));
  969.         sprintf(buffer,"AT+TCPSETUP=%d,",iLinkNum);
  970.         length = strlen((char *)buffer);
  971.         sprintf(&buffer[length],DomainStr);
  972.         length = strlen((char *)buffer);
  973.         if( !Gprs_CreateTCPLink(buffer,length) )  
  974.         {
  975.                 return false;// 建立TCP连接失败；
  976.         }
  977.         return true;
  978. }
  979. bool Gprs_DomainUDPLink(unsigned char iLinkNum)
  980. {
  981.         unsigned int length;
  982.     char buffer[50];       
  983.         memset(buffer,0x00,sizeof(buffer));
  984.         sprintf(buffer,"AT+UDPSETUP=%d,",iLinkNum);
  985.         length = strlen((char *)buffer);
  986.         sprintf(&buffer[length],DomainStr);
  987.         length = strlen((char *)buffer);
  988.         if( !Gprs_CreateUDPLink(buffer,length) )  
  989.         {
  990.                 return false;// 建立TCP连接失败；
  991.         }
  992.         return true;
  993. }

  995. /***************************************************************************************
  996.           *函数名称：Gprs_SendATCommand(char *strCmd,unsigned long len)
  997.           *函数描述：发送AT指令函数
  998.         *入口参数：发送字符串，及长度
  999.         *出口参数：返回一个bool值
  1000. ****************************************************************************************/
  1001. bool Gprs_SendATCommand(char *strCmd,unsigned long len)
  1002. {
  1003.         if(len<=0)
  1004.         return false;
  1005.        
  1006.            UART1_snd((unsigned char*)strCmd,len);
  1007.         return true;
  1008. }

  1010. ///***************************************************************************************
  1011. //          *函数名称：Gprs_ReceiveFromUart(char *data,unsigned long len)
  1012. //          *函数描述：从串口中接收数据
  1013. //        *入口参数：接收到的字符串及长度
  1014. //        *出口参数：无
  1015. // ****************************************************************************************/
  1016. //void Gprs_ReceiveFromUart(char *data,unsigned long len)
  1017. //{
  1018. //        unsigned char i;
  1019. //                unsigned long buflen;
  1020. //                if(gReceiveFlag==0)
  1021. //                {
  1022. //                        memset(gReceiveBuffer ,0x00,sizeof(gReceiveBuffer));
  1023. //                        memcpy(gReceiveBuffer,data,len);
  1024. //                        gReceiveBufferLen = len;
  1025. //                        gReceiveFlag= 1;       
  1026. //                }
  1027. //                else
  1028. //                {
  1029. ……………………

  1031. …………限于本文篇幅 余下代码请从51黑下载附件…………
复制代码

所有资料51hei提供下载:
7213-Modbus.zip (921.66 KB, 下载次数: 19)
回复

使用道具 举报

ID:1 发表于 2018-10-7 00:17 | 显示全部楼层
补全原理图或者详细说明一下电路连接即可获得100+黑币
回复

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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