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

 找回密码
 立即注册

QQ登录

只需一步，快速开始

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

搜索
»论坛 › 嵌入式/单片机论坛 › Arduino › 自己做的一个上传OneNet的上传函数
返回列表 发新帖
查看: 2022|回复: 0
打印 上一主题 下一主题
收起左侧

自己做的一个上传OneNet的上传函数

[复制链接]
跳转到指定楼层
楼主
ID:744379 发表于 2020-5-5 10:54 | 只看该作者 回帖奖励 |倒序浏览 |阅读模式
编了几个用于OneNet上传数据和获取数据的函数，贡献出来


个人感觉使用官方的库比较占内存，太多的功能和函数其实用不上，所以就自己编了几个实用的函数，贡献出来

欢迎大家积极实用OneNet。
  1. void setup() {
  2.   // put your setup code here, to run once:
  3. #define WiFi_Port Serial3
  4. #define Debug_Port Serial
  5. }

  7. void loop() {
  8.   // put your main code here, to run repeatedly:

  10. }

  12. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  13. //本函数用于向OneNet发送数据，根据你的需要可以随意发送同一个设备下的n个数据流的数据点。本函数无返回值。                  //
  14. //***********************************************************************************************************************//
  15. //本函数需要调用函数：String build_Post_HTTP_Header(unsigned long Device, String Host, String Key)                       //
  16. //他用来构造 HTTP头字符串                                                                                                //
  17. //其中 Device 为OneNet上的设备，为无符号长整数型;                                                                        //
  18. //Host 为OneNet的HTTP主机"api.heclouds点com"，可以定义为一个字符串再引，也可直接使用；                                    //
  19. //Key 为 OneNet上对应设备的Apikey，或用户的Masterkey，为字符串型                                                         //
  20. //***********************************************************************************************************************//
  21. //本函数还调用函数 Make_Post_Json(),这是用于构造相应Json字符串的函数；                                                   //
  22. //***********************************************************************************************************************//
  23. //本函数还调用函数  returnmsg_ok_conWiFi();这个函数是判断是否完成了TCP连接；                                             //
  24. //***********************************************************************************************************************//
  25. //本函数还调用函数   returnmsgWiFi();主要是为了查看WiFi模块是否正确接受了发送的数据以及回显情，如不需要可用//来注销；    //
  26. //***********************************************************************************************************************//
  27. //本函数还调用函数    returnmsg_ok_finishWiFi();主要是用来判断OneNet是否返回了正确信息                                   //
  28. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  29. void Post_Data()
  30. {
  31.   String Send_info = build_Post_HTTP_Header(131278, "api.heclouds点com", "b6724PQP4FEVVI3sqMb3QIHh6boA" );
  32.   int len = Send_info.length() + Make_Post_Json().length() + 4;    //计算总长度，如用透传则不需要，+4是加的  WiFi_Port.print("\r\n\r\n"); 两个换行和两个回车；
  33.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  34.   returnmsg_ok_conWiFi();
  35.   delay(500);
  36.   WiFi_Port.print("AT+CIPSEND=");
  37.   returnmsgWiFi();
  38.   WiFi_Port.println(len);
  39.   returnmsgWiFi();
  40.   delay(500);
  41.   WiFi_Port.print(Send_info);
  42.   returnmsgWiFi();
  43.   WiFi_Port.print(Make_Post_Json());
  44.   returnmsgWiFi();
  45.   WiFi_Port.print("\r\n\r\n");
  46.   returnmsg_ok_finishWiFi();
  47. }




  52. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  53. //本函数用于构造一个Json数据串                                                                                   //
  54. //本函数需要调用函数：String Build_Json (String ID, long Value)                                                  //
  55. //其中ID  为OneNet上的设备中”数据流“ID，为字符串型;                                                              //
  56. //Value 为对应的数，为长整数型；                                                                                 //
  57. //他的返回值为构造好的，包含一数据流的数据点Json数据串；                                                         //
  58. //***************************************************************************************************************//
  59. //本函数还调用函数 String ADD_Post_JsonPar(String Json, String ID, long Value)                                   //
  60. //他是用来给已构造好的Json数据串增加一个数据流数据点；                                                           //
  61. //Json 为前面已构造好的一个完整Json数据，ID为需要增加的数据流的ID, Value为对用的数据；                           //
  62. //他的返回值为构造好的含有多个数据流数值的Json串                                                                 //
  63. //***************************************************************************************************************//
  64. //如需增加多个数据流的数据，只需多次调用函数 String ADD_Post_JsonPar(String Json, String ID, long Value)         //
  65. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  66. String Make_Post_Json()
  67. {
  68.   String _Json = Build_Post_Json("A01", random(1000));
  69.   _Json = ADD_Post_JsonPar(_Json, "A02", random(1000));
  70.   _Json = ADD_Post_JsonPar(_Json, "A03", random(1000));
  71.   _Json = ADD_Post_JsonPar(_Json, "A04", random(1000));
  72.   _Json = ADD_Post_JsonPar(_Json, "A05", random(1000));
  73.   _Json = ADD_Post_JsonPar(_Json, "A06", random(1000));
  74.   _Json = ADD_Post_JsonPar(_Json, "A07", random(1000));
  75.   _Json = ADD_Post_JsonPar(_Json, "A08", random(1000));
  76.   _Json = ADD_Post_JsonPar(_Json, "A09", random(1000));
  77.   _Json = ADD_Post_JsonPar(_Json, "A10", random(1000));
  78.   _Json = ADD_Post_JsonPar(_Json, "A11", random(1000));
  79.   _Json = ADD_Post_JsonPar(_Json, "A12", random(1000));
  80.   _Json = ADD_Post_JsonPar(_Json, "A13", random(1000));
  81.   _Json = ADD_Post_JsonPar(_Json, "A14", random(1000));
  82.   _Json = ADD_Post_JsonPar(_Json, "A15", random(1000));
  83.   _Json = ADD_Post_JsonPar(_Json, "A16", random(1000));
  84.   _Json = ADD_Post_JsonPar(_Json, "A17", random(1000));
  85.   _Json = ADD_Post_JsonPar(_Json, "A18", random(1000));
  86.   _Json = ADD_Post_JsonPar(_Json, "A19", random(1000));
  87.   _Json = ADD_Post_JsonPar(_Json, "A20", random(1000));
  88.   return _Json;
  89. }




  94. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  95. //本函数用于构造一个只包含一个数据流数据点的基本Json数据串                                                   //
  96. //其中ID  为OneNet上的设备中”数据流“ID，为字符串型;                                                          //
  97. //Value 为对应的数，为长整数型；                                                                             //
  98. //他的返回值为构造好，包含一数据流的数据点数；                                                               //         
  99. //形成Json数据串如此例：{"datastreams":[{"id":"TEMP","datapoints":[{"value":12345 }]}]}                      //                                                                                                  //
  100. ///////////////////////////////////////////////////////////////////////////////////////////////////////////////
  101. String Build_Post_Json (String ID, long Value)
  102. {
  103.   String _Value = Value + String("");
  104.   String  _Json = "{\"datastreams\":[{\"id\":\"";
  105.   _Json += ID;
  106.   _Json += "\",\"datapoints\":";
  107.   _Json += "[{\"value\":";
  108.   _Json += _Value;
  109.   _Json += "}]}]}";
  110.   return _Json;
  111. }


  114. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  115. //本函数用来给已构造好的Json数据串增加一个数据流数据点；                                                                               //
  116. //Json 为前面已构造好的一个完整Json数据，ID为需要增加的数据流的ID, Value为对用的数据；                                                 //
  117. //他的返回值为构造好的含有多个数据流数值的Json串                                                                                       //
  118. //*************************************************************************************************************************************//
  119. //如需增加多个数据流的数据，只需多次调用函数 String ADD_Post_JsonPar(String Json, String ID, long Value)                               //
  120. //形成Json数据串如此例：{"datastreams":[{"id":"TEMP","datapoints":[{"value":45 }]},{"id":"HUMI","datapoints":[{"value":32 }]}]}        //                    //   
  121. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  122. String ADD_Post_JsonPar(String Json, String ID, long Value)
  123. {
  124.   int LENS = Json.length();
  125.   String _Json = Json.substring(0, LENS - 2);   //-2是先去掉最后两个字符“]}",然后追加”,"以及需要增加的ID的对应Json字符串，并加回"]}"，够造成一个完整的Json数据串
  126.   _Json += +",{\"id\":\"";
  127.   _Json += ID;
  128.   _Json += "\",\"datapoints\":";
  129.   _Json += "[{\"value\":";
  130.   String _Value = Value + String("");
  131.   _Json += _Value;
  132.   _Json += "}]}]}";
  133.   return _Json;

  135. }




  140. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  141. //本函数用于构造POST HTTP头字符串                                                                               //
  142. //其中 Device 为OneNet上的设备，为无符号长整数型;                                                               //
  143. //Host 为OneNet的HTTP主机"api.heclouds点com"，可以定义为一个字符串再引，也可直接使用；                           //
  144. //Key为 OneNet上对应设备的Apikey，或用户的Masterkey，为字符串型                                                 //
  145. //**************************************************************************************************************//
  146. //形成的HTTP头字符串如下：                                                                                      //
  147. //POST http://api.heclouds点com/devices/77654/datapoints HTTP/1.1\r\n    “\r\n”代表一个回车一个换行，两个字符   //
  148. //Host: api.heclouds点com\r\n                                                                                    //
  149. //api-key: asdjoiSKFMdmcdslk1398247\r\n                                                                         //
  150. //Connection: close\r\n                                                                                         //
  151. //Content-Length: 68\r\n\r\n                                 这里要两次回车换行                                 //
  152. //////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  153. String build_Post_HTTP_Header(unsigned long Device, String Host, String Key)
  154. {
  155.   String _Device = String("") + Device;
  156.   int  Lens = Make_Post_Json().length();
  157.   String _lens = Lens + String("");
  158.   String HTTP_Header =  "POST http://api.heclouds点com/devices/" + _Device + "/datapoints HTTP/1.1\r\n";
  159.   HTTP_Header = HTTP_Header + "Host: " + Host + "\r\n";
  160.   HTTP_Header = HTTP_Header +  "api-key: " + Key + "\r\n" ;
  161.   HTTP_Header = HTTP_Header + "Connection: close" + "\r\n" ;
  162.   HTTP_Header = HTTP_Header + "Content-Length: " + _lens + "\r\n\r\n";
  163.   return HTTP_Header;
  164. }
  165. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  166. //本函数用于向OneNet获取(GET)一个或n个数据流的当前数据点，返回值为返回的Json字符串。                                   //
  167. //*********************************************************************************************************************//
  168. //本函数需要调用函数：String build_Post_HTTP_Header(unsigned long Device, String Host, String Key)                     //
  169. //他用来构造 HTTP头字符串                                                                                              //
  170. //其中 Device 为OneNet上的设备，为无符号长整数型;                                                                      //
  171. //Host 为OneNet的HTTP主机"api.heclouds点com"，可以定义为一个字符串再引，也可直接使用；                                  //
  172. //Key 为 OneNet上对应设备的Apikey，或用户的Masterkey，为字符串型                                                       //
  173. //*********************************************************************************************************************//
  174. //本函数还调用函数 Make_GET_Json(),这是用于构造相应Json字符串的函数；                                                  //
  175. //*********************************************************************************************************************//
  176. //本函数还调用函数  returnmsg_ok_conWiFi();这个函数是判断是否完成了TCP连接；                                           //
  177. //*********************************************************************************************************************//
  178. //本函数还调用函数   returnmsgWiFi();主要是为了查看WiFi模块是否正确接受了发送的数据以及回显情，如不需要可用//来注销；  //
  179. //*********************************************************************************************************************//
  180. //本函数还调用函数   returnmsg_GET_S_WiFi();主要是用来生成返回值字符                                                   //
  181. //他的返回值就是包含相应数据流当前数据点值的Json数据串                                                                 //   
  182. //*********************************************************************************************************************//  
  183. /////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
  184. String GET_Datapoints()
  185. {
  186.   int len =  Make_GET_Json().length() + 4;      //计算总长度，如用透传则不需要，+4是加的  WiFi_Port.print("\r\n\r\n"); 两个换行和两个回车；
  187.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  188.   returnmsg_ok_conWiFi();
  189.   delay(1000);
  190.   WiFi_Port.print("AT+CIPSEND=");
  191.   returnmsgWiFi();
  192.   WiFi_Port.println(len);
  193.   returnmsgWiFi();
  194.   delay(1000);
  195.   WiFi_Port.print(Make_GET_Json());
  196.   returnmsgWiFi();
  197.   WiFi_Port.print("\r\n\r\n");
  198.   String _ResulT = returnmsg_GET_S_WiFi();
  199.   WiFi_Port.println("AT+CIPCLOSE");
  200.   return _ResulT;
  201. }





  207. ///////////////////////////////////////////////////////////////////////////////////////////////////
  208. //本函数用于分析String GET_Datapoints()取回的数据流的数据点                                      //
  209. //_Result为String GET_Datapoints()函数取回的结果；                                               //
  210. //_Stream为想要分析的数据                                                                        //
  211. //返回值为对应的数据流的相应数值                                                                 //
  212. //如需分析多个数据，调用多次即可                                                                 //
  213. ///////////////////////////////////////////////////////////////////////////////////////////////////
  214. int Analyze_GET_Result(String _Result, String _Stream)
  215. {
  216.   int _No1 = _Result.indexOf(_Stream);
  217.   String _SubS1 = _Result.substring(_No1 - 22, _No1 - 3);
  218.   int _No2 = _SubS1.indexOf(":");
  219.   int _No3 = _SubS1.indexOf("}");
  220.   String _SubS2 = _SubS1.substring(_No2 + 2, _No3 - 1);
  221.   int _n = atoi(_SubS2.c_str());
  222.   return _n;
  223. }






  230. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  231. //本函数用于构造一个包含一个或多个数据流数据点的GETJson数据串                                           //
  232. //本函数需要调用函数：String Build_GET_HTTP (String ID, String Key, long Device, String Host)           //
  233. //其中ID  为OneNet上的设备中”数据流“ID，为字符串型;                                                     //
  234. //其中 Device 为OneNet上的设备，为无符号长整数型;                                                       //
  235. //Host 为OneNet的HTTP主机"api.heclouds点com"，可以定义为一个字符串再引，也可直接使用；                   //
  236. //Key 为 OneNet上对应设备的Apikey，或用户的Masterkey，为字符串型                                        //
  237. //他的返回值为构造好的，包含相应数据流的数据点Json数据串；                                              //
  238. //******************************************************************************************************//
  239. //本函数还调用函数 String ADD_GET_HTTP_Par(String Json, String ID)                                      //
  240. //他是用来给已构造好的Json数据串增加一个数据流数据点；                                                  //
  241. //Json 为前面已构造好的一个完整Json数据，ID为需要增加的数据流的ID；                                     //
  242. //他的返回值为构造好的含有多个数据流数值的Json串                                                        //
  243. //******************************************************************************************************//
  244. //如需GET多个数据流的数据点，只需多次调用函数 String ADD_GET_HTTP_Par(String Json, String ID)           //
  245. //******************************************************************************************************//   
  246. //////////////////////////////////////////////////////////////////////////////////////////////////////////
  247. String Make_GET_Json()
  248. {
  249.   String _GET_HTTP= Build_GET_HTTP ("T001", "ankjsdvndfrehvngjoitre13290", 46788, "api.heclouds点com");
  250.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T002");
  251.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T003");
  252.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T004");
  253.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T005");
  254.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T006");
  255.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T006");
  256.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T007");
  257.   _GET_HTTP = ADD_GET_HTTP_Par(_GET_HTTP, "T008");
  258.   return _GET_HTTP;
  259. }





  265. ///////////////////////////////////////////////////////////////////////////////////////////////
  266. //本函数用于构造 GET 数据流数据点的Json字符串                                                //
  267. //其中 Device 为OneNet上的设备，为无符号长整数型;                                            //
  268. //Host 为OneNet的HTTP主机"api.heclouds点com"，可以定义为一个字符串再引，也可直接使用；        //
  269. //Key为 OneNet上对应设备的Apikey，或用户的Masterkey，为字符串型                              //
  270. //ID为需要获取数据点的数据流的ID                                                             //
  271. //返回值为构造好的GET HTTP头和Json的组合。                                                   //
  272. //*******************************************************************************************//
  273. //他的返回Json数据串如下：                                                                   //  
  274. // GET /devices/54365/datapoints?datastream_id=K1 HTTP/1.1\r\n                               //  
  275. //Host: api.heclouds点com\r\n                                                                 //
  276. //api-key: asdjoiSKFMdmcdslk1398247\r\n                                                      //
  277. ///////////////////////////////////////////////////////////////////////////////////////////////
  278. String Build_GET_HTTP (String ID, String Key, long Device, String Host)
  279. {
  280.   String _Device = Device + String("");
  281.   String  _HTTP = "GET /devices/" + _Device + "/datapoints?datastream_id=" + ID + " HTTP/1.1\r\n";
  282.   _HTTP = _HTTP + "Host: " + Host + "\r\n";
  283.   _HTTP = _HTTP +  "api-key:" + Key + "\r\n";
  284.   return _HTTP;
  285. }



  289. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  290. //本函数用于对构造好的包含一个数据流数据点的GET HTTP头和Json字符串组合，增加一个需要读取的数据流      //
  291. //Json 为前面已构造好的一个完整Json数据，ID为需要增加的数据流的ID ；                                  //
  292. //返回值为增加一个数据流后的GET HTTP头和Json字符串组合                                                //
  293. //****************************************************************************************************//
  294. //如需增加多个数据流的数据，只需多次调用函数 String ADD_HTTPPar(String Json, String ID)               //
  295. //****************************************************************************************************//
  296. //他的返回Json数据串如下：                                                                            //  
  297. // GET /devices/54365/datapoints?datastream_id=K1,K2 HTTP/1.1\r\n                                     //  
  298. //Host: api.heclouds点com\r\n                                                                          //
  299. //api-key: asdjoiSKFMdmcdslk1398247\r\n                                                               //
  300. ////////////////////////////////////////////////////////////////////////////////////////////////////////
  301. String ADD_GET_HTTP_Par(String Json, String ID)
  302. {
  303.   int _Lens = Json.length();
  304.   int _Point1 = Json.indexOf(" HTTP/1.1");
  305.   String SubString1 = Json.substring(0, _Point1);
  306.   String SubString2 = Json.substring(_Point1, _Lens);
  307.   String _HTTP = Json.substring(0, _Point1);
  308.   _HTTP += ",";
  309.   _HTTP += ID;
  310.   _HTTP += Json.substring(_Point1, _Lens);
  311.   return _HTTP;
  312. }



  316. ///////////////////////////////////////////////////////////////////////////////////////////////
  317. //本函数生成GET命令返回的信息字符串用于后续的分析                                            //
  318. //如大于3分钟未返回结束信息则认为超时失败，执行AT+CIPCLOSE，强行关闭TCP连接                  //
  319. //判断是否结束的关键字是"\"error\":\"succ\"}"                                                //
  320. //返回值为系统返回的Json 数据串                                                              //
  321. ///////////////////////////////////////////////////////////////////////////////////////////////
  322. String returnmsg_GET_S_WiFi()
  323. {
  324.   String _TEMPdata = "";
  325.   unsigned long _PT0 = 0;
  326.   unsigned long _PT1 = 0;
  327.   _PT0 = millis();
  328.   _TEMPdata = "";
  329.   while (1)
  330.   {
  331.     _PT1 = millis();
  332.     if (_PT1 - _PT0 > 180000)
  333.     {
  334.       Debug_Port.println("   ");
  335.       Debug_Port.println("Get error..................");
  336.       WiFi_Port.println("AT+CIPCLOSE");
  337.       return "false";
  338.     }
  339.     while (WiFi_Port.available())
  340.     {
  341.       _TEMPdata += char(WiFi_Port.read());
  342.       // Debug_Port.println(TEMPdata);
  343.       delayMicroseconds(500);
  344.     }
  345.     if (_TEMPdata.indexOf("\"error\":\"succ\"}") > 3)
  346.     {
  347.       Debug_Port.println(_TEMPdata);
  348.       Debug_Port.println("");
  349.       return _TEMPdata;
  350.     }
  351.   }
  352. }




  357. //********************************************************** OneNet  WiFi  send  Data *******************************************************************************************************
  358. /////////////////////////////////////////////////////////////////////////////////////////////
  359. //本函数用于发送四个数据流的数据点，数值为整数类型                                         //
  360. // APIkey OneNet对应设备的MasterKey或Apikey                                                //
  361. // deviceid 对应设备的ID                                                                   //
  362. // Host HTTP服务器名称                                                                     //
  363. // sensorid  对应数据流的ID，thisData 对应数据流的数值                                     //
  364. /////////////////////////////////////////////////////////////////////////////////////////////
  365. //
  366. void sendDataWiFi(String APIkey, int thisData, unsigned long deviceid ,String Host,  String sensorid)
  367. {
  368.   int l = getLength(thisData);
  369.   int D = getLength(deviceid);
  370.   int S = sensorid.length();
  371.   int lenss = 53 + S + l;
  372.   int lll = getLength(lenss);
  373.   int lens = 214 + D + S + l + lll;
  374.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  375.   returnmsg_ok_conWiFi();
  376.   Debug_Port.println("connecting...");
  377.   WiFi_Port.print("AT+CIPSEND=");
  378.   returnmsgWiFi();
  379.   WiFi_Port.println(lens);
  380.   returnmsg_ok_1WiFi();
  381.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  382.   returnmsgWiFi();
  383.   WiFi_Port.print(deviceid);
  384.   returnmsgWiFi();
  385.   WiFi_Port.print("/datapoints HTTP/1.1");
  386.   returnmsgWiFi();
  387.   WiFi_Port.print("\r\n");
  388.   returnmsgWiFi();
  389.   WiFi_Port.print("Host: ");
  390.   returnmsgWiFi();
  391.   WiFi_Port.print(Host);
  392.   returnmsgWiFi();
  393.   WiFi_Port.print("\r\n"); returnmsgWiFi();
  394.   WiFi_Port.print("api-key: ");
  395.   returnmsgWiFi();
  396.   WiFi_Port.print(APIkey);
  397.   returnmsgWiFi();
  398.   WiFi_Port.print("\r\n");
  399. returnmsgWiFi();
  400.   WiFi_Port.println("Connection: close");
  401. returnmsgWiFi();
  402.   WiFi_Port.print("Content-Length: ");
  403.   returnmsgWiFi();
  404. WiFi_Port.print(lenss);
  405. returnmsgWiFi();
  406.   WiFi_Port.print("\r\n");
  407. returnmsgWiFi();
  408.   WiFi_Port.print("\r\n");
  409. returnmsgWiFi();
  410.   WiFi_Port.print("{\"datastreams\":[{\"id\":\"");
  411. WiFi_Port.print(sensorid);
  412. returnmsgWiFi();
  413.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  414. returnmsgWiFi();
  415.   WiFi_Port.print(thisData);
  416. WiFi_Port.print("}]}]}");
  417.   returnmsgWiFi();
  418.   WiFi_Port.print("\r\n");
  419.   WiFi_Port.print("\r\n");
  420.   WiFi_Port.print("\r\n");
  421.   WiFi_Port.print("\r\n");
  422.   returnmsg_ok_finishWiFi();
  423. }




  428. //********************************************************** OneNet  WiFi  send 2 Data *******************************************************************************************************
  429. /////////////////////////////////////////////////////////////////////////////////////////////
  430. //本函数用于发送四个数据流的数据点，数值为整数类型                                         //
  431. // APIkey OneNet对应设备的MasterKey或Apikey                                                //
  432. // deviceid 对应设备的ID                                                                   //
  433. // Host HTTP服务器名称                                                                     //
  434. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                     //
  435. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                     //
  436. /////////////////////////////////////////////////////////////////////////////////////////////
  437. void send2DataWiFi(String APIkey, int Data1, int Data2, unsigned long deviceid,String Host, String sensorid1 , String sensorid2)
  438. {
  439.   int l1 = getLength(Data1);
  440.   int l2 = getLength(Data2);
  441.   int D = getLength(deviceid);
  442.   int S1 = sensorid1.length();
  443.   int S2 = sensorid2.length();
  444.   int lenss = 53 + 36 + S1 + l1 + S2 + l2;      //增加一个数据流Lenss固定长度需要增加36;
  445.   int l3 = getLength(lenss);
  446.   int lens = 214 + 36 + D + S1 + l1 + S2 + l2 + l3; //增加一个数据流Lens固定长度需要增加36;
  447.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  448.   returnmsg_ok_conWiFi();
  449.   Debug_Port.println("connecting...");
  450.   WiFi_Port.print("AT+CIPSEND=");
  451.   returnmsgWiFi();
  452.   WiFi_Port.println(lens);
  453.   returnmsg_ok_1WiFi();
  454.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  455.   returnmsgWiFi();
  456.   WiFi_Port.print(deviceid);
  457.   returnmsgWiFi();
  458.   WiFi_Port.print("/datapoints HTTP/1.1");
  459.   returnmsgWiFi();
  460.   WiFi_Port.print("\r\n");
  461.   returnmsgWiFi();
  462.   WiFi_Port.print("Host: ");
  463.   returnmsgWiFi();
  464.   WiFi_Port.print(Host);
  465.   returnmsgWiFi();
  466.   WiFi_Port.print("\r\n");
  467.   returnmsgWiFi();
  468.   WiFi_Port.print("api-key: ");
  469.   returnmsgWiFi();
  470.   WiFi_Port.print(APIkey);
  471.   returnmsgWiFi();
  472.   WiFi_Port.print("\r\n");
  473.   returnmsgWiFi();
  474.   WiFi_Port.println("Connection: close");
  475.   returnmsgWiFi();
  476.   WiFi_Port.print("Content-Length: ");
  477.   returnmsgWiFi();
  478.   WiFi_Port.print(lenss);
  479.   returnmsgWiFi();
  480.   WiFi_Port.print("\r\n");
  481.   returnmsgWiFi();
  482.   WiFi_Port.print("\r\n");
  483.   returnmsgWiFi();
  484.   ////////////////////////////////////////////////////////////////////sensor data
  485.   WiFi_Port.print("{\"datastreams\":[");
  486.   ///////////////////////////////////////////////////////////////////sensor1
  487.   WiFi_Port.print("{\"id\":\"");
  488.   WiFi_Port.print(sensorid1);
  489.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  490.   WiFi_Port.print(Data1);
  491.   WiFi_Port.print("}]},");
  492.   returnmsgWiFi();
  493.   ///////////////////////////////////////////////////////////////////sensor2
  494.   WiFi_Port.print("{\"id\":\"");
  495.   WiFi_Port.print(sensorid2);
  496.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  497.   WiFi_Port.print(Data2);
  498.   WiFi_Port.print("}]}");
  499.   returnmsgWiFi();
  500.   ///////////////////////////////////////////////////////////////////sensor end
  501.   WiFi_Port.print("]}");
  502.   ////////////////////////////////////////////////////sensor data end
  503.   returnmsgWiFi();
  504.   WiFi_Port.print("\r\n");
  505.   WiFi_Port.print("\r\n");
  506.   WiFi_Port.print("\r\n");
  507.   WiFi_Port.print("\r\n");
  508.   returnmsg_ok_finishWiFi();
  509. }
  510. //********************************************************** OneNet  WiFi  send 3 Data *******************************************************************************************************
  511. /////////////////////////////////////////////////////////////////////////////////////////////
  512. //本函数用于发送四个数据流的数据点，数值为整数类型                                         //
  513. // APIkey OneNet对应设备的MasterKey或Apikey                                                //
  514. // deviceid 对应设备的ID                                                                   //
  515. // Host HTTP服务器名称                                                                     //
  516. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                     //
  517. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                     //
  518. // sensorid3  对应数据流3的ID，Data3 对应数据流3的数值                                     //
  519. /////////////////////////////////////////////////////////////////////////////////////////////
  520. void send3DataWiFi(String APIkey, int Data1, int Data2, int Data3, unsigned long deviceid,String Host, String sensorid1, String sensorid2, String sensorid3)
  521. {
  522.   int l1 = getLength(Data1);
  523.   int l2 = getLength(Data2);
  524.   int l3 = getLength(Data3);
  525.   int D = getLength(deviceid);
  526.   int S1 = sensorid1.length();
  527.   int S2 = sensorid2.length();
  528.   int S3 = sensorid3.length();
  529.   int lenss = 53 + 36 + 36 + S1 + l1 + S2 + l2 + S3 + l3;  //增加一个数据流Lenss固定长度需要增加36,增加2个数据流需要增加2次36;
  530.   int lll = getLength(lenss);
  531.   int lens = 214 + 36 + 36 + D + lll + S1 + l1 + S2 + l2 + S3 + l3; //增加一个数据流Lens固定长度需要增加36,增加2个数据流需要增加2次36;
  532.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  533. returnmsg_ok_conWiFi();
  534.   Debug_Port.println("connecting...");
  535.   WiFi_Port.print("AT+CIPSEND=");
  536.   delay(00);
  537.   returnmsgWiFi();
  538.   WiFi_Port.println(lens);
  539. returnmsg_ok_1WiFi();
  540.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  541. returnmsgWiFi();
  542.   WiFi_Port.print(deviceid);
  543. returnmsgWiFi();
  544.   WiFi_Port.print("/datapoints HTTP/1.1");
  545. returnmsgWiFi();
  546.   WiFi_Port.print("\r\n");
  547. returnmsgWiFi();
  548.   WiFi_Port.print("Host: ");
  549. returnmsgWiFi();
  550.   WiFi_Port.print(Host);
  551. returnmsgWiFi();
  552.   WiFi_Port.print("\r\n");
  553. returnmsgWiFi();
  554.   WiFi_Port.print("api-key: "); returnmsgWiFi();
  555.   WiFi_Port.print(APIkey);
  556. returnmsgWiFi();
  557.   WiFi_Port.print("\r\n");
  558. returnmsgWiFi();
  559.   WiFi_Port.println("Connection: close");
  560. returnmsgWiFi();
  561.   WiFi_Port.print("Content-Length: "); returnmsgWiFi();
  562.   WiFi_Port.print(lenss);
  563. returnmsgWiFi();
  564.   WiFi_Port.print("\r\n");
  565. returnmsgWiFi();
  566.   WiFi_Port.print("\r\n");
  567. returnmsgWiFi();
  568.   ////////////////////////////////////////////////////////////////////sensor data
  569.   WiFi_Port.print("{\"datastreams\":[");
  570.   ///////////////////////////////////////////////////////////////////sensor1
  571.   WiFi_Port.print("{\"id\":\"");
  572. WiFi_Port.print(sensorid1);
  573. WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  574. WiFi_Port.print(Data1);
  575.   WiFi_Port.print("}]},");
  576.   returnmsgWiFi();
  577.   ///////////////////////////////////////////////////////////////////sensor2
  578.   WiFi_Port.print("{\"id\":\"");
  579. WiFi_Port.print(sensorid2);
  580.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  581.   WiFi_Port.print(Data2);
  582.   WiFi_Port.print("}]},");
  583.   returnmsgWiFi();
  584.   ///////////////////////////////////////////////////////////////////sensor2
  585.   WiFi_Port.print("{\"id\":\"");
  586.   WiFi_Port.print(sensorid3);
  587.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  588.   WiFi_Port.print(Data3);
  589.   WiFi_Port.print("}]}");
  590.   returnmsgWiFi();
  591.   ///////////////////////////////////////////////////////////////////sensor end
  592.   WiFi_Port.print("]}");
  593.   ////////////////////////////////////////////////////sensor data end
  594.   returnmsgWiFi();
  595.   WiFi_Port.print("\r\n");
  596.   WiFi_Port.print("\r\n");
  597.   WiFi_Port.print("\r\n");
  598.   WiFi_Port.print("\r\n");
  599.   returnmsg_ok_finishWiFi();
  600. }
  601. //********************************************************** OneNet  WiFi  send 4 Data *******************************************************************************************************
  602. /////////////////////////////////////////////////////////////////////////////////////////////
  603. //本函数用于发送四个数据流的数据点，数值为整数类型                                         //
  604. // APIkey OneNet对应设备的MasterKey或Apikey                                                //
  605. // deviceid 对应设备的ID                                                                   //
  606. // Host HTTP服务器名称                                                                     //
  607. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                     //
  608. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                     //
  609. // sensorid3  对应数据流3的ID，Data3 对应数据流3的数值                                     //
  610. // sensorid4  对应数据流4的ID，Data4 对应数据流4的数值                                     //
  611. /////////////////////////////////////////////////////////////////////////////////////////////
  612. void send4DataWiFi(String APIkey, int Data1, int Data2, int Data3, int Data4, unsigned long deviceid,String Host, String sensorid1, String sensorid2, String sensorid3, String sensorid4)
  613. {
  614.   int l1 = getLength(Data1);
  615.   int l2 = getLength(Data2);
  616.   int l3 = getLength(Data3);
  617.   int l4 = getLength(Data4);
  618.   int D = getLength(deviceid);
  619.   int S1 = sensorid1.length();
  620.   int S2 = sensorid2.length();
  621.   int S3 = sensorid3.length();
  622.   int S4 = sensorid4.length();
  623.   int lenss = 53 + 36 + 36 + 36 + S1 + l1 + S2 + l2 + S3 + l3 + S4 + l4; //增加一个数据流Lenss固定长度需要增加36,增加3个数据流需要增加3次36;
  624.   int lll = getLength(lenss);
  625.   int lens = 214 + 36 + 36 + 36 + D + lll + S1 + l1 + S2 + l2 + S3 + l3 + S4 + l4; //增加一个数据流Lens固定长度需要增加36,增加3个数据流需要增加3次36;
  626.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  627.   returnmsg_ok_conWiFi();
  628.   Debug_Port.println("connecting...");
  629.   WiFi_Port.print("AT+CIPSEND=");
  630.   delay(00);
  631.   returnmsgWiFi();
  632.   WiFi_Port.println(lens);
  633.   returnmsg_ok_1WiFi();
  634.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  635.   returnmsgWiFi();
  636.   WiFi_Port.print(deviceid);
  637.   returnmsgWiFi();
  638.   WiFi_Port.print("/datapoints HTTP/1.1");
  639.   returnmsgWiFi();
  640.   WiFi_Port.print("\r\n");
  641.   returnmsgWiFi();
  642.   WiFi_Port.print("Host: ");
  643.   returnmsgWiFi();
  644.   WiFi_Port.print(Host);
  645.   returnmsgWiFi();
  646.   WiFi_Port.print("\r\n");
  647.   returnmsgWiFi();
  648.   WiFi_Port.print("api-key: ");
  649.   returnmsgWiFi();
  650.   WiFi_Port.print(APIkey);
  651.   returnmsgWiFi();
  652.   WiFi_Port.print("\r\n");
  653.   returnmsgWiFi();
  654.   WiFi_Port.println("Connection: close");
  655.   returnmsgWiFi();
  656.   WiFi_Port.print("Content-Length: ");
  657.   returnmsgWiFi();
  658.   WiFi_Port.print(lenss);
  659.   returnmsgWiFi();
  660.   WiFi_Port.print("\r\n");
  661.   returnmsgWiFi();
  662.   WiFi_Port.print("\r\n");
  663.   returnmsgWiFi();
  664.   ////////////////////////////////////////////////////////////////////sensor data
  665.   WiFi_Port.print("{\"datastreams\":[");
  666.   ///////////////////////////////////////////////////////////////////sensor1
  667.   WiFi_Port.print("{\"id\":\"");
  668.   WiFi_Port.print(sensorid1);
  669.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  670.   WiFi_Port.print(Data1);
  671.   WiFi_Port.print("}]},");
  672.   returnmsgWiFi();
  673.   ///////////////////////////////////////////////////////////////////sensor2
  674.   WiFi_Port.print("{\"id\":\"");
  675.   WiFi_Port.print(sensorid2);
  676.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  677.   WiFi_Port.print(Data2);
  678.   WiFi_Port.print("}]},");
  679.   returnmsgWiFi();
  680.   ///////////////////////////////////////////////////////////////////sensor3
  681.   WiFi_Port.print("{\"id\":\"");
  682.   WiFi_Port.print(sensorid3);
  683.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  684.   WiFi_Port.print(Data3);
  685.   WiFi_Port.print("}]},");
  686.   returnmsgWiFi();
  687.   ///////////////////////////////////////////////////////////////////sensor4
  688.   WiFi_Port.print("{\"id\":\"");
  689.   WiFi_Port.print(sensorid4);
  690.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  691.   WiFi_Port.print(Data4);
  692.   WiFi_Port.print("}]}");
  693.   returnmsgWiFi();
  694.   //////////////////////////////////////////////////////////////sensor end
  695.   WiFi_Port.print("]}");
  696.   ////////////////////////////////////////////////////sensor data end
  697.   returnmsgWiFi();
  698.   WiFi_Port.print("\r\n");
  699.   WiFi_Port.print("\r\n");
  700.   WiFi_Port.print("\r\n");
  701.   WiFi_Port.print("\r\n");
  702.   returnmsg_ok_finishWiFi();
  703. }

  705. //********************************************************** OneNet  WiFi  send  Data *******************************************************************************************************
  706. /////////////////////////////////////////////////////////////////////////////////////////
  707. //本函数用于发送一个数据流的数据点，数值为字符数组类型                                 //
  708. // APIkey OneNet对应设备的MasterKey或Apikey                                            //
  709. // deviceid 对应设备的ID                                                               //
  710. // Host HTTP服务器名称                                                                 //
  711. // sensorid  对应数据流1的ID，thisData对应数据流1的数值                                //
  712. /////////////////////////////////////////////////////////////////////////////////////////
  713. void sendDataWiFiC(String APIkey, char *thisData, unsigned long deviceid,String Host, String sensorid )
  714. {
  715.   int l = strlen(thisData);
  716.   int D = getLength(deviceid);
  717.   int S = sensorid.length();
  718.   int lenss = 53 + S + l;
  719.   int lll = getLength(lenss);
  720.   int lens = 214 + D + S + l + lll;
  721.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  722.   returnmsg_ok_conWiFi();
  723.   Debug_Port.println("connecting...");
  724.   WiFi_Port.print("AT+CIPSEND=");
  725.   returnmsgWiFi();
  726.   WiFi_Port.println(lens);
  727.   returnmsg_ok_1WiFi();
  728.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  729.   returnmsgWiFi();
  730.   WiFi_Port.print(deviceid);
  731.   returnmsgWiFi();
  732.   WiFi_Port.print("/datapoints HTTP/1.1");
  733.   returnmsgWiFi();
  734.   WiFi_Port.print("\r\n");
  735.   returnmsgWiFi();
  736.   WiFi_Port.print("Host: ");
  737.   returnmsgWiFi();
  738.   WiFi_Port.print(Host);
  739.   returnmsgWiFi();
  740.   WiFi_Port.print("\r\n");
  741.   returnmsgWiFi();
  742.   WiFi_Port.print("api-key: ");
  743.   returnmsgWiFi();
  744.   WiFi_Port.print(APIkey);
  745.   returnmsgWiFi();
  746.   WiFi_Port.print("\r\n");
  747.   returnmsgWiFi();
  748.   WiFi_Port.println("Connection: close");
  749.   returnmsgWiFi();
  750.   WiFi_Port.print("Content-Length: ");
  751.   returnmsgWiFi();
  752.   WiFi_Port.print(lenss);
  753.   returnmsgWiFi();
  754.   WiFi_Port.print("\r\n");
  755.   returnmsgWiFi();
  756.   WiFi_Port.print("\r\n");
  757.   returnmsgWiFi();
  758.   WiFi_Port.print("{\"datastreams\":[{\"id\":\"");
  759.   WiFi_Port.print(sensorid);
  760.   returnmsgWiFi();
  761.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  762.   returnmsgWiFi();
  763.   WiFi_Port.print(thisData);
  764.   WiFi_Port.print("}]}]}");
  765.   returnmsgWiFi();
  766.   WiFi_Port.print("\r\n");
  767.   WiFi_Port.print("\r\n");
  768.   WiFi_Port.print("\r\n");
  769.   WiFi_Port.print("\r\n");
  770.   returnmsg_ok_finishWiFi();
  771. }

  773. //********************************************************** OneNet  WiFi  send 2 Data *******************************************************************************************************
  774. //////////////////////////////////////////////////////////////////////////////////////////
  775. //本函数用于发送四个数据流的数据点，数值为字符串类型                                    //
  776. // APIkey OneNet对应设备的MasterKey或Apikey                                             //
  777. // deviceid 对应设备的ID                                                                //
  778. // Host HTTP服务器名称                                                                  //
  779. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                  //
  780. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                  //
  781. //////////////////////////////////////////////////////////////////////////////////////////
  782. void send2DataWiFiC(String APIkey, char * Data1, char * Data2, unsigned long deviceid,String Host, String sensorid1 , String sensorid2)
  783. {
  784.   int l1 = strlen(Data1);
  785.   int l2 = strlen(Data2);
  786.   int D = getLength(deviceid);
  787.   int S1 = sensorid1.length();
  788.   int S2 = sensorid2.length();
  789.   int lenss = 53 + 36 + S1 + l1 + S2 + l2;      //增加一个数据流Lenss固定长度需要增加36,增加1个数据流需要增加1次36;
  790.   int l3 = getLength(lenss);
  791.   int lens = 214 + 36 + D + S1 + l1 + S2 + l2 + l3; //增加一个数据流Lens固定长度需要增加36,增加1个数据流需要增加1次36;
  792.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  793.   returnmsg_ok_conWiFi();
  794.   Debug_Port.println("connecting...");
  795.   WiFi_Port.print("AT+CIPSEND=");
  796.   delay(00);
  797.   returnmsgWiFi();
  798.   WiFi_Port.println(lens);
  799.   returnmsg_ok_1WiFi();
  800.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  801.   returnmsgWiFi();
  802.   WiFi_Port.print(deviceid);
  803.   returnmsgWiFi();
  804.   WiFi_Port.print("/datapoints HTTP/1.1");
  805.   returnmsgWiFi();
  806.   WiFi_Port.print("\r\n");
  807.   returnmsgWiFi();
  808.   WiFi_Port.print("Host: ");
  809.   returnmsgWiFi();
  810.   WiFi_Port.print(Host);
  811.   returnmsgWiFi();
  812.   WiFi_Port.print("\r\n");
  813.   returnmsgWiFi();
  814.   WiFi_Port.print("api-key: ");
  815.   returnmsgWiFi();
  816.   WiFi_Port.print(APIkey);
  817.   returnmsgWiFi();
  818.   WiFi_Port.print("\r\n");
  819.   returnmsgWiFi();
  820.   WiFi_Port.println("Connection: close");
  821.   returnmsgWiFi();
  822.   WiFi_Port.print("Content-Length: ");
  823.   returnmsgWiFi();
  824.   WiFi_Port.print(lenss);
  825.   returnmsgWiFi();
  826.   WiFi_Port.print("\r\n");
  827.   returnmsgWiFi();
  828.   WiFi_Port.print("\r\n");
  829.   returnmsgWiFi();
  830.   ////////////////////////////////////////////////////////////////////sensor data
  831.   WiFi_Port.print("{\"datastreams\":[");
  832.   ///////////////////////////////////////////////////////////////////sensor1
  833.   WiFi_Port.print("{\"id\":\"");
  834.   WiFi_Port.print(sensorid1);
  835.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  836.   WiFi_Port.print(Data1);
  837.   WiFi_Port.print("}]},");
  838.   returnmsgWiFi();
  839.   ///////////////////////////////////////////////////////////////////sensor2
  840.   WiFi_Port.print("{\"id\":\"");
  841.   WiFi_Port.print(sensorid2);
  842.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  843.   WiFi_Port.print(Data2);
  844.   WiFi_Port.print("}]}");
  845.   returnmsgWiFi();
  846.   ///////////////////////////////////////////////////////////////////sensor end
  847.   WiFi_Port.print("]}");
  848.   ////////////////////////////////////////////////////sensor data end
  849.   returnmsgWiFi();
  850.   WiFi_Port.print("\r\n");
  851.   WiFi_Port.print("\r\n");
  852.   WiFi_Port.print("\r\n");
  853.   WiFi_Port.print("\r\n");
  854.   returnmsg_ok_finishWiFi();
  855. }
  856. //********************************************************** OneNet  WiFi  send 3 Data *******************************************************************************************************
  857. //////////////////////////////////////////////////////////////////////////////////////////
  858. //本函数用于发送四个数据流的数据点，数值为字符串类型                                    //
  859. // APIkey OneNet对应设备的MasterKey或Apikey                                             //
  860. // deviceid 对应设备的ID                                                                //
  861. // Host HTTP服务器名称                                                                  //
  862. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                  //
  863. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                  //
  864. // sensorid3  对应数据流3的ID，Data3 对应数据流3的数值                                  //
  865. //////////////////////////////////////////////////////////////////////////////////////////
  866. void send3DataWiFiC(String APIkey, char * Data1, char * Data2, char * Data3, unsigned long deviceid,String Host, String sensorid1, String sensorid2, String sensorid3)
  867. {
  868.   int l1 = strlen(Data1);
  869.   int l2 = strlen(Data2);
  870.   int l3 = strlen(Data3);
  871.   int D = getLength(deviceid);
  872.   int S1 = sensorid1.length();
  873.   int S2 = sensorid2.length();
  874.   int S3 = sensorid3.length();
  875.   int lenss = 53 + 36 + 36 + S1 + l1 + S2 + l2 + S3 + l3;  //增加一个数据流Lens固定长度需要增加36,增加2个数据流需要增加2次36;
  876.   int lll = getLength(lenss);
  877.   int lens = 214 + 36 + 36 + D + lll + S1 + l1 + S2 + l2 + S3 + l3; //增加一个数据流Lens固定长度需要增加36,增加2个数据流需要增加2次36;
  878.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  879.   returnmsg_ok_conWiFi();
  880.   Debug_Port.println("connecting...");
  881.   WiFi_Port.print("AT+CIPSEND=");
  882.   delay(00);
  883.   returnmsgWiFi();
  884.   WiFi_Port.println(lens);
  885.   returnmsg_ok_1WiFi();
  886.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  887.   returnmsgWiFi();
  888.   WiFi_Port.print(deviceid);
  889.   returnmsgWiFi();
  890.   WiFi_Port.print("/datapoints HTTP/1.1");
  891.   returnmsgWiFi();
  892.   WiFi_Port.print("\r\n");
  893.   returnmsgWiFi();
  894.   WiFi_Port.print("Host: ");
  895.   returnmsgWiFi();
  896.   WiFi_Port.print(Host);
  897.   returnmsgWiFi();
  898.   WiFi_Port.print("\r\n");
  899.   returnmsgWiFi();
  900.   WiFi_Port.print("api-key: ");
  901.   returnmsgWiFi();
  902.   WiFi_Port.print(APIkey);
  903.   returnmsgWiFi();
  904.   WiFi_Port.print("\r\n");
  905.   returnmsgWiFi();
  906.   WiFi_Port.println("Connection: close");
  907.   returnmsgWiFi();
  908.   WiFi_Port.print("Content-Length: ");
  909.   returnmsgWiFi();
  910.   WiFi_Port.print(lenss);
  911.   returnmsgWiFi();
  912.   WiFi_Port.print("\r\n");
  913.   returnmsgWiFi();
  914.   WiFi_Port.print("\r\n");
  915.   returnmsgWiFi();
  916.   ////////////////////////////////////////////////////////////////////sensor data
  917.   WiFi_Port.print("{\"datastreams\":[");
  918.   ///////////////////////////////////////////////////////////////////sensor1
  919.   WiFi_Port.print("{\"id\":\"");
  920.   WiFi_Port.print(sensorid1);
  921.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  922.   WiFi_Port.print(Data1);
  923.   WiFi_Port.print("}]},");
  924.   returnmsgWiFi();
  925.   ///////////////////////////////////////////////////////////////////sensor2
  926.   WiFi_Port.print("{\"id\":\"");
  927.   WiFi_Port.print(sensorid2);
  928.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  929.   WiFi_Port.print(Data2);
  930.   WiFi_Port.print("}]},");
  931.   returnmsgWiFi();
  932.   ///////////////////////////////////////////////////////////////////sensor2
  933.   WiFi_Port.print("{\"id\":\"");
  934.   WiFi_Port.print(sensorid3);
  935.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  936.   WiFi_Port.print(Data3);
  937.   WiFi_Port.print("}]}");
  938.   returnmsgWiFi();
  939.   ///////////////////////////////////////////////////////////////////sensor end
  940.   WiFi_Port.print("]}");
  941.   ////////////////////////////////////////////////////sensor data end
  942.   returnmsgWiFi();
  943.   WiFi_Port.print("\r\n");
  944.   WiFi_Port.print("\r\n");
  945.   WiFi_Port.print("\r\n");
  946.   WiFi_Port.print("\r\n");
  947.   returnmsg_ok_finishWiFi();
  948. }
  949. //********************************************************** OneNet  WiFi  send 4 Data *******************************************************************************************************
  950. //////////////////////////////////////////////////////////////////////////////////////////
  951. //本函数用于发送四个数据流的数据点，数值为字符串类型                                    //
  952. // APIkey OneNet对应设备的MasterKey或Apikey                                             //
  953. // deviceid 对应设备的ID                                                                //
  954. // Host HTTP服务器名称                                                                  //
  955. // sensorid1  对应数据流1的ID，Data1 对应数据流1的数值                                  //
  956. // sensorid2  对应数据流2的ID，Data2 对应数据流2的数值                                  //
  957. // sensorid3  对应数据流3的ID，Data3 对应数据流3的数值                                  //
  958. // sensorid4  对应数据流4的ID，Data4 对应数据流4的数值                                  //
  959. //////////////////////////////////////////////////////////////////////////////////////////
  960. void send4DataWiFiC(String APIkey, char * Data1, char * Data2, char * Data3, char * Data4, unsigned long deviceid,String Host, String sensorid1, String sensorid2, String sensorid3, String sensorid4)
  961. {
  962.   int l1 = strlen(Data1);
  963.   int l2 = strlen(Data2);
  964.   int l3 = strlen(Data3);
  965.   int l4 = strlen(Data4);
  966.   int D = getLength(deviceid);
  967.   int S1 = sensorid1.length();
  968.   int S2 = sensorid2.length();
  969.   int S3 = sensorid3.length();
  970.   int S4 = sensorid4.length();
  971.   int lenss = 53 + 36 + 36 + 36 + S1 + l1 + S2 + l2 + S3 + l3 + S4 + l4; //增加一个数据流Lens固定长度需要增加36,增加3个数据流需要增加3次36;
  972.   int lll = getLength(lenss);
  973.   int lens = 214 + 36 + 36 + 36 + D + lll + S1 + l1 + S2 + l2 + S3 + l3 + S4 + l4; //增加一个数据流Lens固定长度需要增加36,增加3个数据流需要增加3次36;
  974.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  975.   returnmsg_ok_conWiFi();
  976.   Debug_Port.println("connecting...");
  977.   WiFi_Port.print("AT+CIPSEND=");
  978.   delay(00);
  979.   returnmsgWiFi();
  980.   WiFi_Port.println(lens);
  981.   returnmsg_ok_1WiFi();
  982.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  983.   returnmsgWiFi();
  984.   WiFi_Port.print(deviceid);
  985.   returnmsgWiFi();
  986.   WiFi_Port.print("/datapoints HTTP/1.1");
  987.   returnmsgWiFi();
  988.   WiFi_Port.print("\r\n");
  989.   returnmsgWiFi();
  990.   WiFi_Port.print("Host: ");
  991.   returnmsgWiFi();
  992.   WiFi_Port.print(Host);
  993.   returnmsgWiFi();
  994.   WiFi_Port.print("\r\n");
  995.   returnmsgWiFi();
  996.   WiFi_Port.print("api-key: ");
  997.   returnmsgWiFi();
  998.   WiFi_Port.print(APIkey);
  999.   returnmsgWiFi();
  1000.   WiFi_Port.print("\r\n");
  1001.   returnmsgWiFi();
  1002.   WiFi_Port.println("Connection: close");
  1003.   returnmsgWiFi();
  1004.   WiFi_Port.print("Content-Length: ");
  1005.   returnmsgWiFi();
  1006.   WiFi_Port.print(lenss);
  1007.   returnmsgWiFi();
  1008.   WiFi_Port.print("\r\n");
  1009.   returnmsgWiFi();
  1010.   WiFi_Port.print("\r\n");
  1011.   returnmsgWiFi();
  1012.   ////////////////////////////////////////////////////////////////////sensor data
  1013.   WiFi_Port.print("{\"datastreams\":[");
  1014.   ///////////////////////////////////////////////////////////////////sensor1
  1015.   WiFi_Port.print("{\"id\":\"");
  1016.   WiFi_Port.print(sensorid1);
  1017.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  1018.   WiFi_Port.print(Data1);
  1019.   WiFi_Port.print("}]},");
  1020.   returnmsgWiFi();
  1021.   ///////////////////////////////////////////////////////////////////sensor2
  1022.   WiFi_Port.print("{\"id\":\"");
  1023.   WiFi_Port.print(sensorid2);
  1024.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  1025.   WiFi_Port.print(Data2);
  1026.   WiFi_Port.print("}]},");
  1027.   returnmsgWiFi();
  1028.   ///////////////////////////////////////////////////////////////////sensor3
  1029.   WiFi_Port.print("{\"id\":\"");
  1030.   WiFi_Port.print(sensorid3);
  1031.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  1032.   WiFi_Port.print(Data3);
  1033.   WiFi_Port.print("}]},");
  1034.   returnmsgWiFi();
  1035.   ///////////////////////////////////////////////////////////////////sensor4
  1036.   WiFi_Port.print("{\"id\":\"");
  1037.   WiFi_Port.print(sensorid4);
  1038.   WiFi_Port.print("\",\"datapoints\":[{\"value\":");
  1039.   WiFi_Port.print(Data4);
  1040.   WiFi_Port.print("}]}");
  1041.   returnmsgWiFi();
  1042.   //////////////////////////////////////////////////////////////sensor end
  1043.   WiFi_Port.print("]}");
  1044.   ////////////////////////////////////////////////////sensor data end
  1045.   returnmsgWiFi();
  1046.   WiFi_Port.print("\r\n");
  1047.   WiFi_Port.print("\r\n");
  1048.   WiFi_Port.print("\r\n");
  1049.   WiFi_Port.print("\r\n");
  1050.   returnmsg_ok_finishWiFi();
  1051. }
  1052. //********************************************************** OneNet  WiFi  send  GPS Data *******************************************************************************************************
  1053. ////////////////////////////////////////////////////////////////////////////////////
  1054. //本函数用于发送GPS数据流的数据点，数值为整数类型                                 //
  1055. // APIkey OneNet对应设备的MasterKey或Apikey                                       //
  1056. // deviceid 对应设备的ID                                                          //
  1057. // Host HTTP服务器名称                                                            //
  1058. // sensorid  对应GPS数据流的ID                                                    //
  1059. // LON  对应经度的数值                                                            //
  1060. // LAT  对应纬度数值                                                              //
  1061. // HEIGH  对应海拔高度数值；                                                      //
  1062. ////////////////////////////////////////////////////////////////////////////////////
  1063. void sendGPSDataWiFi(char* HEIGH, unsigned long deviceid, String sensorid,String Host, char* LON, char* LAT, String APIkey )
  1064. {
  1065.   int l = strlen(HEIGH);
  1066.   int D = getLength(deviceid);
  1067.   int S = sensorid.length();
  1068.   int Lonlen = strlen(LON);
  1069.   int Latlen = strlen(LAT);
  1070.   int lenss = 53 + 28 + S + l + Lonlen + Latlen;
  1071.   int l2 = getLength(lenss);
  1072.   int lens = 214 + 28 + D + S + l + Lonlen + Latlen + l2;
  1073.   WiFi_Port.println(lens);
  1074.   WiFi_Port.println("AT+CIPSTART=\"TCP\",\"183.230.40.33\",80");
  1075.   returnmsg_ok_conWiFi();
  1076.   Debug_Port.println("connecting...");
  1077.   WiFi_Port.print("AT+CIPSEND=");
  1078.   returnmsgWiFi();
  1079.   WiFi_Port.println(lens);
  1080.   returnmsg_ok_1WiFi();
  1081.   WiFi_Port.print("POST http://api.heclouds点com/devices/");
  1082.   returnmsgWiFi();
  1083.   WiFi_Port.print(deviceid);
  1084.   returnmsgWiFi();
  1085.   WiFi_Port.print("/datapoints HTTP/1.1");
  1086.   returnmsgWiFi();
  1087.   WiFi_Port.print("\r\n");
  1088.   returnmsgWiFi();
  1089.   WiFi_Port.print("Host: ");
  1090.   returnmsgWiFi();
  1091.   WiFi_Port.print(Host);
  1092.   returnmsgWiFi();
  1093.   WiFi_Port.print("\r\n");
  1094.   returnmsgWiFi();
  1095.   WiFi_Port.print("api-key: ");
  1096.   returnmsgWiFi();
  1097.   WiFi_Port.print(APIkey);
  1098.   returnmsgWiFi();
  1099.   WiFi_Port.print("\r\n");
  1100.   returnmsgWiFi();
  1101.   WiFi_Port.println("Connection: close");
  1102.   returnmsgWiFi();
  1103.   WiFi_Port.print("Content-Length: ");
  1104.   returnmsgWiFi();
  1105.   WiFi_Port.print(lenss);
  1106.   returnmsgWiFi();  WiFi_Port.print("\r\n");
  1107.   returnmsgWiFi();
  1108.   WiFi_Port.print("\r\n");
  1109.   returnmsgWiFi();
  1110.   WiFi_Port.print("{\"datastreams\":[{\"id\":\"");
  1111.   returnmsgWiFi();
  1112.   WiFi_Port.print(sensorid);
  1113.   returnmsgWiFi();
  1114.   WiFi_Port.print("\",\"datapoints\":[{\"value\":{\"lon\":\"");
  1115.   returnmsgWiFi();
  1116.   WiFi_Port.print(LON);
  1117.   returnmsgWiFi();
  1118.   WiFi_Port.print("\",\"lat\":\"");
  1119.   returnmsgWiFi();
  1120.   WiFi_Port.print(LAT);
  1121.   returnmsgWiFi();
  1122.   WiFi_Port.print("\",\"ele\":\"");
  1123.   returnmsgWiFi();
  1124.   WiFi_Port.print(HEIGH);
  1125.   returnmsgWiFi();
  1126.   WiFi_Port.print("\"}}]}]}");
  1127.   returnmsgWiFi();
  1128.   WiFi_Port.print("\r\n");
  1129.   returnmsgWiFi();
  1130.   WiFi_Port.print("\r\n");
  1131.   WiFi_Port.print("\r\n");
  1132.   WiFi_Port.print("\r\n");
  1133.   returnmsg_ok_finishWiFi();
  1134. }
  1135. ///////////////////////////////////////////////////////////////////////////////
  1136. //本函数用于判断串口发挥至是否有关键字“OK”                                   //
  1137. //如60秒内无正确返回，强制执行AT+CIPCLOSE，强行关闭TCP连接                   //
  1138. ///////////////////////////////////////////////////////////////////////////////
  1139. void returnmsg_okWiFi()
  1140. {
  1141.   String _TEMPdata = "";
  1142.   unsigned long _PT0 = 0;
  1143.   unsigned long _PT1 = 0;
  1144.   _PT0 = millis();
  1145.   _TEMPdata = "";
  1146.   while (1)
  1147.   {
  1148.     _PT1 = millis();
  1149.     if (_PT1 - _PT0 > 60000)
  1150.     {
  1151.       Debug_Port.println("   ");
  1152.       Debug_Port.println("Get error..................");
  1153.       WiFi_Port.println("AT+CIPCLOSE");
  1154.       return ;
  1155.     }
  1156.     while (WiFi_Port.available())
  1157.     {
  1158.       _TEMPdata += char(WiFi_Port.read());
  1159.       //Debug_Port.println(_TEMPdata);
  1160.       delay(2);
  1161.     }
  1162.     if (_TEMPdata.indexOf("OK") > 0)
  1163.     {
  1164.       // Debug_Port.println(_TEMPdata);
  1165.       Debug_Port.println("");
  1166.       _TEMPdata = "";
  1167.       break;
  1168.     }
  1169.     else
  1170.     {
  1171.       delay(1);
  1172.     }
  1173.   }
  1174.   return;
  1175. }
  1176. ///////////////////////////////////////////////////////////////////
  1177. //本函数用于打印WiFi的串口返回信息，用于Debug，无实际作用        //
  1178. ///////////////////////////////////////////////////////////////////
  1179. void returnmsgWiFi()
  1180. {
  1181.   String  _TEMPdata = "";
  1182.   while (!WiFi_Port.available())
  1183.   {
  1184.   }
  1185.   while (WiFi_Port.available())
  1186.   {
  1187.     _TEMPdata += char(WiFi_Port.read());
  1188.     delay(1);
  1189.   }
  1190.   Debug_Port.print(_TEMPdata);
  1191.   _TEMPdata = "";
  1192.   return;
  1193. }
  1194. ///////////////////////////////////////////////////////////////////////////////
  1195. //本函数用于判断串口发挥至是否有关键字“OK”和“ready”                      //
  1196. //如60秒内无正确返回，强制执行AT+CIPCLOSE，强行关闭TCP连接                   //
  1197. ///////////////////////////////////////////////////////////////////////////////
  1198. void returnmsg_ok_readyWiFi()
  1199. {
  1200.   String  _TEMPdata = "";
  1201.   unsigned long _PT0 = 0;
  1202.   unsigned long _PT1 = 0;
  1203.   _PT0 = millis();
  1204.   _TEMPdata = "";
  1205.   while (1)
  1206.   {
  1207.     _PT1 = millis();
  1208.     if (_PT1 - _PT0 > 60000)
  1209.     {
  1210.       Debug_Port.println("   ");
  1211.       Debug_Port.println("Get error..................");
  1212.       WiFi_Port.println("AT+CIPCLOSE");
  1213.       
  1214.       return ;
  1215.     }
  1216.     while (WiFi_Port.available())
  1217.     {
  1218.       _TEMPdata += char(WiFi_Port.read());
  1219.       //DebugDebug_Port.println(_TEMPdata);
  1220.       delayMicroseconds(800);
  1221.     }
  1222.     if ((_TEMPdata.indexOf("OK") > 0) && (_TEMPdata.indexOf("ready") > 0))
  1223.     {
  1224.       // Debug_Port.println(_TEMPdata);
  1225.       Debug_Port.println("");
  1226.       _TEMPdata = "";
  1227.       break;
  1228.     }
  1229.   }
  1230.   return;
  1231. }


  1234. ///////////////////////////////////////////////////////////////////////////////
  1235. //本函数用于判断是否正确的完成了TCP连接；                                    //
  1236. //判断标志为返回了“OK”以及"CONNECT"                                        //
  1237. //如超过20秒还没收到以上两个关键字，则主动执行一次关闭连接操作并退出         //
  1238. ///////////////////////////////////////////////////////////////////////////////
  1239. void returnmsg_ok_conWiFi()
  1240. {
  1241.   String  _TEMPdata = "";
  1242.   unsigned long _PT0 = 0;
  1243.   unsigned long _PT1 = 0;
  1244.   _PT0 = millis();
  1245.   _TEMPdata = "";
  1246.   while (1)
  1247.   {
  1248.     _PT1 = millis();
  1249.     if (_PT1 - _PT0 > 20000)
  1250.     {
  1251.       Debug_Port.println("   ");
  1252.       Debug_Port.println("Get error..................");
  1253.       WiFi_Port.println("AT+CIPCLOSE");
  1254.       returnmsgWiFi();
  1255.       return ;
  1256.     }
  1257.     while (WiFi_Port.available())
  1258.     {
  1259.       _TEMPdata += char(WiFi_Port.read());
  1260.       delay(1);
  1261.     }
  1262.     if ((_TEMPdata.indexOf("OK") > 3) && (_TEMPdata.indexOf("CONNECT") > 0))
  1263.     {
  1264.       Debug_Port.println(_TEMPdata);
  1265.       Debug_Port.println("");
  1266.       _TEMPdata = "";
  1267.       break;
  1268.     }
  1269.   }
  1270.   return;
  1271. }



  1275. ////////////////////////////////////////////////////////////////////////////////////
  1276. //本函数用于判断服务器收到相应的命令后是否正确的执行并返回了相应的信息。          //
  1277. //判断标志为返回了“OK”以及"CLOSED"                                              //
  1278. //如超过20秒还没收到以上两个关键字，则主动执行一次关闭连接操作并退出。            //
  1279. ////////////////////////////////////////////////////////////////////////////////////
  1280. void returnmsg_ok_finishWiFi()
  1281. {
  1282.   String  _TEMPdata = "";
  1283.   unsigned long _PT0 = 0;
  1284.   unsigned long _PT1 = 0;
  1285.   _PT0 = millis();
  1286.   _TEMPdata = "";
  1287.   while (1)
  1288.   {
  1289.     _PT1 = millis();
  1290.     if (_PT1 - _PT0 > 20000)
  1291.     {
  1292.       Debug_Port.println("   ");
  1293.       Debug_Port.println("Get error..................");
  1294.       WiFi_Port.println("AT+CIPCLOSE");
  1295.       returnmsgWiFi();
  1296.       return ;
  1297.     }
  1298.     while (WiFi_Port.available())
  1299.     {
  1300.       _TEMPdata += char(WiFi_Port.read());
  1301.       // Debug_Port.println(_TEMPdata);
  1302.       delayMicroseconds(700);
  1303.     }
  1304.     if ((_TEMPdata.indexOf("CLOSED") > 3) && (_TEMPdata.indexOf("OK") > 0))
  1305.     {
  1306.       Debug_Port.println(_TEMPdata);
  1307.       Debug_Port.println("");
  1308.       _TEMPdata = "";
  1309.       break;
  1310.     }
  1311.     else
  1312.     {
  1313.       ;
  1314.     }
  1315.   }
  1316.   return;
  1317. }


  1320. /////////////////////////////////////////////////////////////////////////////////////////
  1321. //本函数用于判断CIPSEND后是否返回了“OK”或“close”                                   //
  1322. //收到任何一个都退出。                                                                 //
  1323. /////////////////////////////////////////////////////////////////////////////////////////
  1324. void returnmsg_ok_errWiFi()
  1325. {
  1326.   String  _TEMPdata = "";
  1327.   unsigned long _PT0 = 0;
  1328.   unsigned long _PT1 = 0;
  1329.   _PT0 = millis();
  1330.   _TEMPdata = "";
  1331.   while (1)
  1332.   {
  1333.     while ( WiFi_Port.available())
  1334.     {
  1335.       _TEMPdata += char( WiFi_Port.read());
  1336.       //Debug_Port.println(_TEMPdata);
  1337.       delay(2);
  1338.     }
  1339.     if ((_TEMPdata.indexOf("OK") > 1) || (_TEMPdata.indexOf("ERROR") > 1))
  1340.     {
  1341.       Debug_Port.println(_TEMPdata);
  1342.       Debug_Port.println("");
  1343.       _TEMPdata = "";
  1344.       break ;
  1345.     }
  1346.   }
  1347.   return ;

  1349. }
  1350. /////////////////////////////////////////////////////////////////////////////////////////
  1351. //本函数用于判断CIPSEND后是否返回了“OK”和“close”                                   //
  1352. //如超过20秒没有还没收到以上两个关键字，则主动执行一次关闭连接操作并退出。             //
  1353. /////////////////////////////////////////////////////////////////////////////////////////
  1354. void returnmsg_ok_closeWiFi()
  1355. {
  1356.   String   _TEMPdata = "";
  1357.   unsigned long _PT0 = 0;
  1358.   unsigned long _PT1 = 0;
  1359.   _PT0 = millis();
  1360.   _TEMPdata = "";
  1361.   while (1)
  1362.   {
  1363.     _PT1 = millis();
  1364.     if (_PT1 - _PT0 > 20000)
  1365.     {
  1366.       Debug_Port.println("   ");
  1367.       Debug_Port.println("Get error..................");
  1368.       WiFi_Port.println("AT+CIPCLOSE");
  1369.       
  1370.       return ;
  1371.     }
  1372.     while (WiFi_Port.available())
  1373.     {
  1374.       _TEMPdata += char(WiFi_Port.read());
  1375.       // DebugDebug_Port.println(_TEMPdata);
  1376.       delayMicroseconds(700);
  1377.     }
  1378.     if ((_TEMPdata.indexOf("close") > 3) && (_TEMPdata.indexOf("OK") > 0))
  1379.     {
  1380.       Debug_Port.println(_TEMPdata);
  1381.       Debug_Port.println("");
  1382.       _TEMPdata = "";
  1383.       break;
  1384.     }
  1385.     else
  1386.     {
  1387.       ;
  1388.     }
  1389.   }
  1390.   return;
  1391. }
  1392. /////////////////////////////////////////////////////////////////////////////////////////
  1393. //本函数用于判断CIPSEND后是否返回了“>”                                               //
  1394. //如超过20秒没有还没收到以上关键字，则主动执行一次关闭连接操作并退出。                 //
  1395. /////////////////////////////////////////////////////////////////////////////////////////
  1396. void returnmsg_ok_1WiFi()
  1397. {
  1398.   String _TEMPdata = "";
  1399.   unsigned long _PT0 = 0;
  1400.   unsigned long _PT1 = 0;
  1401.   _PT0 = millis();
  1402.   _TEMPdata = "";
  1403.   while (1)
  1404.   {
  1405.     _PT1 = millis();
  1406.     if (_PT1 - _PT0 > 20000)
  1407.     {
  1408.       Debug_Port.println("   ");
  1409.       Debug_Port.println("Get error..................");
  1410.       WiFi_Port.println("AT+CIPCLOSE");
  1411.       
  1412.       return ;
  1413.     }
  1414.     while (WiFi_Port.available())
  1415.     {
  1416.       _TEMPdata += char(WiFi_Port.read());
  1417.       // DebugDebug_Port.println(_TEMPdata);
  1418.       delay(2);
  1419.     }
  1420.     if (_TEMPdata.indexOf(">") > 0)
  1421.     {
  1422.       Debug_Port.println(_TEMPdata);
  1423.       Debug_Port.println("");
  1424.       _TEMPdata = "";
  1425.       break;
  1426.     }
  1427.     else
  1428.     {
  1429.       delay(1);
  1430.     }
  1431.   }
  1432.   return;
  1433. }
  1434. ///////////////////////////////////////////////////////////////////
  1435. //本函数用于计算一个长整型数值的长度                             //
  1436. //返回值为int类型数值                                            //
  1437. ///////////////////////////////////////////////////////////////////
  1438. int getLength(unsigned long someValue)
  1439. {
  1440.   int digits = 1;
  1441.   int dividend = someValue / 10;
  1442.   while (dividend > 0) {
  1443.     dividend = dividend / 10;
  1444.     digits++;
  1445.   }
  1446.   return digits;
  1447. }
复制代码


OneNet_POST_GET_Function.rar

5.66 KB, 下载次数: 8, 下载积分: 黑币 -5

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

使用道具 举报

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

本版积分规则

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

Powered by 单片机教程网

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