ArduinoHTTP请求获取任意服务器的时间_asyncudp arduino

作者：AllinToyou | 2024-04-23 03:52:44
踩
asyncudp arduino
由于 NTP时间服务器经常炸，无缘无故无来由的炸，各自UDP包的丢包，各自封锁导致不得不使用其他方法进行授时。无奈Arduino的库也存在2038问题，年最大仅255。试问2225年之后怎么办？所以我自己写了一套时间算法，解决时间问题。
总的来说用了AsyncUDP库https://github.com/me-no-dev/ESPAsyncUDP
和各自基础库
原理任何HTTP包都含请求报头和响应报头
响应报头中截取出 Date: Tue, 27 Jun 2023 23:10:58 GMT
这个字符串再进行分析即可得到当前的时间。但有的服务器设置存在问题或压根没有设置时间所以报头中也没有，所以就选几个大厂的发包就可以了，内容数据直接抛弃。
HTTPS算法来自https://www.bilibili.com/read/cv17367361/
准确来说授时不需要HTTPS.
#include <Arduino.h>

#include <WiFi.h>
#include <HTTPClient.h>
#include <WiFiClientSecure.h>

//加密算法库
// #include <mbedtls/pk.h>
// #include <mbedtls/rsa.h>
// #include <mbedtls/pem.h>       //https://blog.csdn.net/qdlyd/article/details/131084726?spm=1001.2014.3001.5501
// #include <mbedtls/sha256.h>    //https://blog.csdn.net/imba_wolf/article/details/122417540
// #include <mbedtls/ctr_drbg.h>  //https://www.trustedfirmware.org/projects/mbed-tls/
// #include <mbedtls/entropy.h>   //https://johanneskinzig.de/index.php/files/26/Arduino-mbedtls/9/gettingstartedmbedtlsarduino.7z
// #include <arduino_base64.hpp>  //https://github.com/dojyorin/arduino_base64 随便拉的库 库管理搜base64_encode作者dojyorin
//URL处理
//#include <UrlEncode.h>
//UDPz底层库
#include <AsyncUDP.h>
AsyncUDP udp;  //UDP监听常驻内存
//全局时间变量
const unsigned int localPort = 23511;
unsigned long long ntpTime = 0;  //最后一次对时距离1970年的秒数
typedef struct {
  uint8_t Second;
  uint8_t Minute;
  uint8_t Hour;
  uint8_t Wday;  // day of week, Sunday is day 1
  uint8_t Day;
  uint8_t Month;
  uint32_t Year;  // offset from 1970;END AY 4294967295YEAR
} tmElement64s_t;
#define SECS_PER_MIN ((time_t)(60UL))
#define SECS_PER_HOUR ((time_t)(3600UL))
#define SECS_PER_DAY ((time_t)(SECS_PER_HOUR * 24UL))
#define LEAP_YEAR(Y) (((1970 + (Y)) > 0) && !((1970 + (Y)) % 4) && (((1970 + (Y)) % 100) || !((1970 + (Y)) % 400)))
static const uint8_t monthDays[] = { 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };  // API starts months from 1, this array starts from 0
bool needupadte = 1;                                                                    //需要授时标志位 1代表需要联网授时
unsigned long timesendudp;                                                              //发出UDP包的时间（micros()）开机后微秒数
unsigned long timegetudp;                                                               //接收UDP包的时间（micros()）开机后微秒数


const char *rootCACertificate =
  "-----BEGIN CERTIFICATE-----\n"
  "MIIDrzCCApegAwIBAgIQCDvgVpBCRrGhdWrJWZHHSjANBgkqhkiG9w0BAQUFADBh\n"
  "MQswCQYDVQQGEwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3\n"
  "d3cuZGlnaWNlcnQuY29tMSAwHgYDVQQDExdEaWdpQ2VydCBHbG9iYWwgUm9vdCBD\n"
  "QTAeFw0wNjExMTAwMDAwMDBaFw0zMTExMTAwMDAwMDBaMGExCzAJBgNVBAYTAlVT\n"
  "MRUwEwYDVQQKEwxEaWdpQ2VydCBJbmMxGTAXBgNVBAsTEHd3dy5kaWdpY2VydC5j\n"
  "b20xIDAeBgNVBAMTF0RpZ2lDZXJ0IEdsb2JhbCBSb290IENBMIIBIjANBgkqhkiG\n"
  "9w0BAQEFAAOCAQ8AMIIBCgKCAQEA4jvhEXLeqKTTo1eqUKKPC3eQyaKl7hLOllsB\n"
  "CSDMAZOnTjC3U/dDxGkAV53ijSLdhwZAAIEJzs4bg7/fzTtxRuLWZscFs3YnFo97\n"
  "nh6Vfe63SKMI2tavegw5BmV/Sl0fvBf4q77uKNd0f3p4mVmFaG5cIzJLv07A6Fpt\n"
  "43C/dxC//AH2hdmoRBBYMql1GNXRor5H4idq9Joz+EkIYIvUX7Q6hL+hqkpMfT7P\n"
  "T19sdl6gSzeRntwi5m3OFBqOasv+zbMUZBfHWymeMr/y7vrTC0LUq7dBMtoM1O/4\n"
  "gdW7jVg/tRvoSSiicNoxBN33shbyTApOB6jtSj1etX+jkMOvJwIDAQABo2MwYTAO\n"
  "BgNVHQ8BAf8EBAMCAYYwDwYDVR0TAQH/BAUwAwEB/zAdBgNVHQ4EFgQUA95QNVbR\n"
  "TLtm8KPiGxvDl7I90VUwHwYDVR0jBBgwFoAUA95QNVbRTLtm8KPiGxvDl7I90VUw\n"
  "DQYJKoZIhvcNAQEFBQADggEBAMucN6pIExIK+t1EnE9SsPTfrgT1eXkIoyQY/Esr\n"
  "hMAtudXH/vTBH1jLuG2cenTnmCmrEbXjcKChzUyImZOMkXDiqw8cvpOp/2PV5Adg\n"
  "06O/nVsJ8dWO41P0jmP6P6fbtGbfYmbW0W5BjfIttep3Sp+dWOIrWcBAI+0tKIJF\n"
  "PnlUkiaY4IBIqDfv8NZ5YBberOgOzW6sRBc4L0na4UU+Krk2U886UAb3LujEV0ls\n"
  "YSEY1QSteDwsOoBrp+uvFRTp2InBuThs4pFsiv9kuXclVzDAGySj4dzp30d8tbQk\n"
  "CAUw7C29C79Fv1C5qfPrmAESrciIxpg0X40KPMbp1ZWVbd4=\n"
  "-----END CERTIFICATE-----\n";

const char *pemKey = R"(
-----BEGIN RSA PRIVATE KEY-----

-----END RSA PRIVATE KEY-----
)";
/*
String alipaysign(String alipaydata) {
  // 需要包含以下库
  // #include <mbedtls/pk.h>
  // #include <mbedtls/rsa.h>
  // #include <mbedtls/pem.h>
  // #include <mbedtls/sha256.h>
  // #include <mbedtls/ctr_drbg.h>
  // #include <mbedtls/entropy.h>//https://johanneskinzig.de/index.php/files/26/Arduino-mbedtls/9/gettingstartedmbedtlsarduino.7z
  // #include <arduino_base64.hpp>//https://github.com/dojyorin/arduino_base64 随便拉的库 库管理搜base64_encode作者dojyorin
  //关键私钥从LITTLE FS中获得 由于私钥太占内存所以我将其写至签名函数内，避免继续在上层函数中继续占用内存
  //私钥 这里通过读取littleFS从SPIflash中读取
  //存在重大漏洞 如果有人取下SPIflash做逆向工程可以读出您的私钥伪造您的签名使用支付宝转账接口盗取您的支付宝资金
  //需要恢复
  // String alipayprivatekey = getValueByKey("alipayprivatekey");  //从Little存储中的简易键值存储中读取私钥
  const char *data = alipaydata.c_str();
  //需要恢复
  // const char *pemKey = alipayprivatekey.c_str();
  mbedtls_pk_context key;
  mbedtls_rsa_context *rsa = NULL;  //实际未利用子RSA函数库中的签名算法
  mbedtls_ctr_drbg_context ctr_drbg;

  mbedtls_pk_init(&key);
  mbedtls_ctr_drbg_init(&ctr_drbg);

  const char *personalization = "random_seed142";  //随机数种子 签名计算不牵扯随机数生成器 无需设置根据真实事件产生的随机数种子
  mbedtls_entropy_context entropy;
  mbedtls_entropy_init(&entropy);
  mbedtls_ctr_drbg_seed(&ctr_drbg, mbedtls_entropy_func, &entropy, (const unsigned char *)personalization, strlen(personalization));
  //载入RSA密钥
  int ret = mbedtls_pk_parse_key(&key, (const unsigned char *)pemKey, strlen(pemKey) + 1, NULL, 0);
  if (ret != 0) {
    Serial.println("Failed to parse private key.");
    Serial.println(ret);
    return "";
  }
  // 计算SHA256哈希值
  unsigned char hash[32];
  mbedtls_sha256((const unsigned char *)data, strlen(data), hash, 0);
  // 使用密钥对哈希值进行数字签名
  unsigned char signature[256];
  size_t signatureLen;
  ret = mbedtls_pk_sign(&key, MBEDTLS_MD_SHA256, hash, sizeof(hash), signature, &signatureLen, mbedtls_ctr_drbg_random, &ctr_drbg);
  if (ret != 0) {
    Serial.println("Failed to sign the data.");
    return "";
  }
  char base64signoutput[base64::encodeLength(sizeof(signature))];  //制造一个长度仅为base生成长度一致的字符串
  base64::encode(signature, sizeof(signature), base64signoutput);  //把字符串base64算法存入字符数组base64signoutput
  // 清理资源
  mbedtls_pk_free(&key);
  mbedtls_ctr_drbg_free(&ctr_drbg);
  mbedtls_entropy_free(&entropy);
  String strbase64signoutput;
  strbase64signoutput = base64signoutput;
  return strbase64signoutput;
}
*/
/*
String alipaytradequery(const String &tradeno) {
  // String url = "https://openapi.alipay.com/gateway.do?biz_content=%7B%22out_trade_no%22%3A%22202108230101010014b%22%2C%22total_amount%22%3A0.01%2C%22subject%22%3A%22%5Cu5546%5Cu54c1%22%2C%22extend_params%22%3A%7B%22sys_service_provider_id%22%3A%222088931278114101%22%7D%7D&app_id=2021001194613478&version=1.0&format=json&sign_type=RSA2&method=alipay.trade.precreate&timestamp=2023-06-26+12%3A11%3A20&auth_token=&alipay_sdk=alipay-sdk-php-2020-04-15&terminal_type=&terminal_info=&prod_code=&notify_url=&charset=UTF-8&app_auth_token=&app_cert_sn=0fbfea6f1c396ed1ee67302f2d035201&alipay_root_cert_sn=687b59193f3f462dd5336e5abf83c5d8_02941eef3187dddf3d3b83462e1dfcf6&target_app_id=&sign=eg%2FkZa8%2BEj5GmfZDZfpMDgnpwOOglZtN7rfeBKSerBOUuaxjEKdaxpuSuYK4RSyBmwgiWM%2BA%2BRLH4MCVSOaCC64QnMrW1bi6fRaSW%2BGXzLlyh1%2FCl5BV5TVFgFWPqPbR%2FfUj1sbs3woRc%2FJ9KM3WudojIY2uzOTl6grojy0k5BvMRcQY6Km8rAu3UwCodv9YWGxSW5AzxY%2Fi6y8gRoYSSEbKrLsLNnE6IVAShi%2Bl7QlY%2BoFXdfpieen7ou0s6lTaonkPM3xjB1ONlWKMINQi3b7FyTnlFG5jZXCzpTmWHkeGq8GFmRo9%2FMRlC0WFG%2BrTQbcEXY9lBRa%2FOGk0XE8akQ%3D%3D";
  String param = "alipay_root_cert_sn=687b59193f3f462dd5336e5abf83c5d8_02941eef3187dddf3d3b83462e1dfcf6&alipay_sdk=alipay-sdk-php-2020-04-15&app_cert_sn=0fbfea6f1c396ed1ee67302f2d035201&app_id=2021001194613478&biz_content={\"out_trade_no\":\"202108230101010012b\"}&charset=UTF-8&format=json&method=alipay.trade.query&sign_type=RSA2&timestamp=2023-06-28 04:46:27&version=1.0";
  String sign = urlEncode(alipaysign(param));
  // param =urlEncode(param);
  param = "alipay_root_cert_sn=687b59193f3f462dd5336e5abf83c5d8_02941eef3187dddf3d3b83462e1dfcf6&alipay_sdk=alipay-sdk-php-2020-04-15&app_auth_token=&app_cert_sn=0fbfea6f1c396ed1ee67302f2d035201&app_id=2021001194613478&auth_token=&biz_content=%7B%22out_trade_no%22%3A%22202108230101010012b%22%7D&charset=UTF-8&format=json&method=alipay.trade.query&notify_url=&prod_code=&sign_type=RSA2&target_app_id=&terminal_info=&terminal_type=&timestamp=2023-06-28+04%3A46%3A27&version=1.0";
  param = param + "&sign=" + sign;
  param = "/gateway.do?" + param;  //
  Serial.print(param);
  return param;
  // String param = "alipay_root_cert_sn=";
  // param += getValueByKey("alipayrootcertsn");
  // param += String("&app_cert_sn=");
  // param += getValueByKey("appcertsn");
  // param += String("&app_id=");
  // param += getValueByKey("appid");
  // param += String("&biz_content={\"out_trade_no\":\"");
  // param += tradeno;
  // param += String("\"}&charset=UTF-8&format=json&method=alipay.trade.query&sign_type=RSA2&timestamp=");
  // param += getalipaytime();
  // param += String("&version=1.0");
  // String sign = alipaysign(param);
  // param += "&sign=";
  // param += urlEncode(sign);
  // url+=param;
  // char* charurlArray = new char[url.length() + 1];
  // url.toCharArray(charurlArray, url.length() + 1);
  // return charurlArray;
}
*/
/**
 * 功能：HTTPS请求封装！
 * @param host：请求域名（String类型）
 * @param url：请求地址（String类型）
 * @param parameter：请求参数(String类型)(默认""")
 * @param fingerprint：服务器证书指纹 (String类型)(默认""")
 * @param Port：请求端口(int类型)(默认：443)
 * @param Receive_cache：接收缓存(int类型)(默认：1024)
 * @return 成功返回请求的内容(String类型) 失败则返回"0"
 * */
String HTTPS_request(String host, String postRequest, int Port = 443, int Receive_cache = 1024) {
  WiFiClientSecure HTTPS;  //建立WiFiClientSecure对象
  HTTPS.setCACert(rootCACertificate);
  // HTTPClient https;//不用官方库
  // https.begin(wificlient,String(url));
  // Serial.print("原始URLA");
  // Serial.println(url);
  postRequest = (String)("GET ") + postRequest + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "User-Agent: Mozilla/5.0 (iPhone; CPU iPhone OS 13_2_3 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/13.0.3 Mobile/15E148 Safari/604.1 Edg/103.0.5060.53" + "\r\n\r\n";
  HTTPS.setInsecure();  //不进行服务器身份认证
  int cache = sizeof(postRequest) + 10;
  Serial.print("原始URLB");
  Serial.println(postRequest);
  Serial.print("发送缓存：");
  Serial.println(postRequest);
  Serial.print("发送缓存大小：");
  Serial.println(cache);
  // HTTPS.setBufferSizes(Receive_cache, cache); //接收和发送缓存大小
  HTTPS.setTimeout(15000);  //设置等待的最大毫秒数
  Serial.println("初始化参数完毕！\n开始连接服务器==>>>>>");
  if (!HTTPS.connect(host.c_str(), Port)) {
    delay(100);
    Serial.println();
    Serial.println("服务器连接失败！");
    return "0";
  } else {
    Serial.println("服务器连接成功！\r");
    Serial.println("发送请求：\n" + postRequest);
  }
  HTTPS.print(postRequest.c_str());  // 发送HTTP请求

  // 检查服务器响应信息。通过串口监视器输出服务器状态码和响应头信息
  // 从而确定ESP8266已经成功连接服务器
  Serial.println("获取响应信息========>：\r");
  Serial.println("响应头：");
  while (HTTPS.connected()) {
    String line = HTTPS.readStringUntil('\n');
    Serial.println(line);
    if (line == "\r") {
      Serial.println("响应头输出完毕！");  // Serial.println("响应头屏蔽完毕！\r");
      break;
    }
  }
  Serial.println("截取响应体==========>");
  String line;
  while (HTTPS.connected()) {
    line = HTTPS.readStringUntil('\n');  // Serial.println(line);
                                         // if (line.length() > 10)
    break;
  }
  Serial.println("响应体信息：\n" + line);
  Serial.println("====================================>");
  Serial.println("变量长度：" + String(line.length()));
  Serial.println("变量大小：" + String(sizeof(line)) + "字节");
  Serial.println("====================================>");
  HTTPS.stop();  //操作结束，断开服务器连接
  delay(500);
  return line;
}


bool HTTPS_GETTIME(String host, String postRequest, int Port = 443, int Receive_cache = 1024) {
  WiFiClientSecure HTTPS;  //建立WiFiClientSecure对象
  HTTPS.setCACert(rootCACertificate);
  postRequest = (String)("GET ") + postRequest + " HTTP/1.1\r\n" + "Host: " + host + "\r\n" + "User-Agent: ESP32WiFiClientSecure" + "\r\n\r\n";
  HTTPS.setInsecure();  //不进行服务器身份认证
  int cache = sizeof(postRequest) + 10;
  // Serial.print("原始URLB");
  // Serial.println(postRequest);
  // Serial.print("发送缓存：");
  // Serial.println(postRequest);
  // Serial.print("发送缓存大小：");
  // Serial.println(cache);
  // HTTPS.setBufferSizes(Receive_cache, cache); //接收和发送缓存大小
  HTTPS.setTimeout(15000);  //设置等待的最大毫秒数
  // Serial.println("初始化参数完毕！\n开始连接服务器==>>>>>");
  if (!HTTPS.connect(host.c_str(), Port)) {
    // delay(100);
    // Serial.println();
    Serial.println("服务器连接失败！");
    return 0;
  } else {
    Serial.println("服务器连接成功！\r");
    // Serial.println("发送请求：\n" + postRequest);
  }
  HTTPS.print(postRequest.c_str());  // 发送HTTP请求

  // 检查服务器响应信息。通过串口监视器输出服务器状态码和响应头信息
  // 从而确定ESP8266已经成功连接服务器
  Serial.println("获取响应信息========>：\r");
  Serial.println("响应头：");
  String inputString;  //用一个字符串接收时间变量
  while (HTTPS.connected()) {
    inputString = HTTPS.readStringUntil('\n');
    if (inputString.startsWith("Date: ")) {
      Serial.println(inputString);
      break;
    }
    if (inputString == "\r") {
      Serial.println("响应头输出完毕！");  // Serial.println("响应头屏蔽完毕！\r");
      break;
    }
  }

  char *tokens[6];  // 用于存储分割后的子字符串
  int tokenCount = 0;

  char *str = strdup(inputString.c_str());  // 复制输入字符串，并将其转换为字符数组

  char *token = strtok(str, " ");  // 使用空格作为分隔符

  while (token != NULL && tokenCount < 6) {
    tokens[tokenCount] = token;  // 存储子字符串
    tokenCount++;

    token = strtok(NULL, " ");  // 继续分割下一个子字符串
  }

  // 检查是否成功分割字符串
  if (tokenCount != 6) { return 0; }
  // 分隔后的子字符串数组
  String year = String(tokens[4]);
  String month = String(tokens[3]);
  String day = String(tokens[2]);
  String time = String(tokens[5]);

  // 进一步处理截取到的子字符串
  Serial.println("Year: " + year);
  Serial.println("Month: " + month);
  Serial.println("Day: " + day);

  // 分割时间部分，使用冒号作为分隔符
  char *timeTokens[3];  // 用于存储分割后的时间子字符串
  int timeTokenCount = 0;

  char *timeStr = strdup(time.c_str());  // 复制时间字符串，并将其转换为字符数组

  char *timeToken = strtok(timeStr, ":");  // 使用冒号作为分隔符

  while (timeToken != NULL && timeTokenCount < 3) {
    timeTokens[timeTokenCount] = timeToken;  // 存储时间子字符串
    timeTokenCount++;

    timeToken = strtok(NULL, ":");  // 继续分割下一个时间子字符串
  }

  if (timeTokenCount != 3) { return 0; }
  String hour = String(timeTokens[0]);
  String minute = String(timeTokens[1]);
  String second = String(timeTokens[2]);

  Serial.println("Hour: " + hour);
  Serial.println("Minute: " + minute);
  Serial.println("Second: " + second);


  free(timeStr);  // 释放分配的内存


  free(str);  // 释放分配的内存
  //此时已分割好所有字符串
  //对月份进行转换 先做一个对象数组
  // String monthAbbreviation = String(month);
  String monthAbbreviations[] = {
    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  };

  int monthNumbers[] = {
    1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12
  };

  int monthNumber = -1;  // 初始化月份数字

  // 在数组中查找月份缩写，并获取对应的月份数字
  for (int i = 0; i < sizeof(monthAbbreviations) / sizeof(monthAbbreviations[0]); i++) {
    if (month == monthAbbreviations[i]) {
      monthNumber = monthNumbers[i];
      break;
    }
  }
  if (monthNumber == -1) { return 0; }  //如果月份不存在则返回报错
  // 输出转换后的结果
  // if (monthNumber != -1) {
  //   Serial.println("Month number: " + String(monthNumber));
  // } else {
  //   Serial.println("Invalid input");
  // }

  // monthNumber = monthMap[month];

  //此时可以使用Arduino自带的setTime(int hr,int min,int sec,int dy, int mnth, int yr) 但该函数存在32位年溢出问题
  tmElement64s_t tm;
  tm.Year = strtoul(year.c_str(), nullptr, 10) - 1970;
  tm.Month = monthNumber;
  tm.Day = strtoul(day.c_str(), nullptr, 10);
  tm.Hour = strtoul(hour.c_str(), nullptr, 10);
  tm.Minute = strtoul(minute.c_str(), nullptr, 10);
  tm.Second = strtoul(second.c_str(), nullptr, 10);
  ntpTime = makeTime(tm);  //将时间戳赋值给全局变量ntpTime;
  Serial.println("授时时间戳");
  Serial.println(ntpTime);

  struct timeval tv;  //ESP32核心库定义此结构体用于赋值ESP32内置RTC
  tv.tv_sec = 0;
  tv.tv_usec = 0;
  settimeofday(&tv, NULL);
  needupadte = 0;
  return 1;
}

uint64_t makeTime(const tmElement64s_t &tm) {
  // assemble time elements into time_t
  // note year argument is offset from 1970 (see macros in time.h to convert to other formats)
  // previous version used full four digit year (or digits since 2000),i.e. 2009 was 2009 or 9

  int i;
  uint64_t seconds;

  // seconds from 1970 till 1 jan 00:00:00 of the given year
  seconds = tm.Year * (SECS_PER_DAY * 365);
  for (i = 0; i < tm.Year; i++) {
    if (LEAP_YEAR(i)) {
      seconds += SECS_PER_DAY;  // add extra days for leap years
    }
  }

  // add days for this year, months start from 1
  for (i = 1; i < tm.Month; i++) {
    if ((i == 2) && LEAP_YEAR(tm.Year)) {
      seconds += SECS_PER_DAY * 29;
    } else {
      seconds += SECS_PER_DAY * monthDays[i - 1];  //monthDay array starts from 0
    }
  }
  seconds += (tm.Day - 1) * SECS_PER_DAY;
  seconds += tm.Hour * SECS_PER_HOUR;
  seconds += tm.Minute * SECS_PER_MIN;
  seconds += tm.Second;
  return seconds;
}

String getalipaytime() {
  struct timeval tv;  //创造一个结构体用于重置内部RTC
  gettimeofday(&tv, NULL);
  tmElement64s_t tm;
  break64Time(ntpTime + tv.tv_sec + 28800, tm);
  char month[2];
  sprintf(month, "%02d", tm.Month);
  char day[2];
  sprintf(day, "%02d", tm.Day);
  char hour[2];
  sprintf(hour, "%02d", tm.Hour);
  char minute[2];
  sprintf(minute, "%02d", tm.Minute);
  char second[2];
  sprintf(second, "%02d", tm.Second);
  String result = String(tm.Year) + String("-") + String(month) + String("-") + String(day) + String(" ") + String(hour) + String(":") + String(minute) + String(":") + String(second);
  return result;
}
void break64Time(uint64_t timeInput, tmElement64s_t &tm) {
  // break the given time_t into time components
  // this is a more compact version of the C library localtime function
  // note that year is offset from 1970 !!!

  uint32_t year;
  uint8_t month, monthLength;
  uint64_t time;
  unsigned long days;

  time = (uint64_t)timeInput;
  tm.Second = time % 60;
  time /= 60;  // now it is minutes
  tm.Minute = time % 60;
  time /= 60;  // now it is hours
  tm.Hour = time % 24;
  time /= 24;                      // now it is days
  tm.Wday = ((time + 4) % 7) + 1;  // Sunday is day 1

  year = 0;
  days = 0;
  while ((unsigned)(days += (LEAP_YEAR(year) ? 366 : 365)) <= time) {
    year++;
  }
  tm.Year = year + 1970;  // year is offset from 1970
  // Serial.println("内部年");
  // Serial.println(year);
  days -= LEAP_YEAR(year) ? 366 : 365;
  time -= days;  // now it is days in this year, starting at 0

  days = 0;
  month = 0;
  monthLength = 0;
  for (month = 0; month < 12; month++) {
    if (month == 1) {  // february
      if (LEAP_YEAR(year)) {
        monthLength = 29;
      } else {
        monthLength = 28;
      }
    } else {
      monthLength = monthDays[month];
    }

    if (time >= monthLength) {
      time -= monthLength;
    } else {
      break;
    }
  }
  tm.Month = month + 1;  // jan is month 1
  tm.Day = time + 1;     // day of month
}

void getNtpTimeAsync() {  //发UDP包请求时间后调用句柄监听

  IPAddress ntpIpAddress;
  byte packetBuffer[48];
  packetBuffer[0] = 0b00101011;  // LI, Version, Mode 不闰秒 ntpv5 客户端
  packetBuffer[1] = 0;           // Stratum, or type of clock时钟精度 1最高15最低
  packetBuffer[2] = 6;
  packetBuffer[3] = 0x00;
  char *ntpServer = "pool.ntp.org";  //time.nist.gov只有协议3 pool.ntp.org CN.NTP.ORG.CN

  if (WiFi.hostByName(ntpServer, ntpIpAddress)) {


    udp.writeTo(packetBuffer, 48, ntpIpAddress, 123);
    timesendudp = micros();
  } else {
    // Serial.println("Failed to resolve NTP server");
  }
}
//回调后调用句柄
void handleNtpResponse(AsyncUDPPacket packet) {
  int packlength = packet.length();

  if (packlength != 0) {
    timegetudp = micros();
    if (timegetudp < timesendudp) { return; }
    if ((timegetudp - timesendudp) > 3000000) { return; }  //如果对时包返回的过晚则代表网络拥塞此次对时失败
    byte packetBuffer[packlength];
    packet.read(packetBuffer, packlength);
    // Serial.println("当前服务器");
    // Serial.println(ntpServer);
    unsigned long bite1 = word(0x00, packetBuffer[0]);
    bite1 = bite1 & 0x38;
    bite1 = bite1 >> 3;
    Serial.println("版本号 只有第5版的NTP协议才能避免2038问题 如无需请注释下方2行");
    Serial.println(bite1);
    if (bite1 != 5) { return; }  //如果对时版本号不对则代表服务器不支持ntp5

    // Serial.println("原始数据");
    // for (size_t i = 0; i < packlength; i++) {
    // if(i%4==0){Serial.println();}
    // Serial.printf("%02x",packetBuffer[i]);
    // Serial.print(packetBuffer[i], HEX);}

    // Serial.print(" ");
    // }

    // 提取时间戳字段

    unsigned Era = packetBuffer[5];
    unsigned ntpgetTimehighWord = word(packetBuffer[32], packetBuffer[33]);
    unsigned ntpgetTimelowWord = word(packetBuffer[34], packetBuffer[35]);
    unsigned ntpgetTimeMicrohighWord = word(packetBuffer[36], packetBuffer[37]);
    unsigned ntpgetTimeMicrolowWord = word(packetBuffer[38], packetBuffer[39]);
    unsigned long long ntpgetTime = (static_cast<unsigned long long>(ntpgetTimehighWord) << 48) | (static_cast<unsigned long long>(ntpgetTimelowWord) << 32) | (static_cast<unsigned long long>(ntpgetTimeMicrohighWord) << 16) | ntpgetTimeMicrolowWord;
    unsigned ntpsendTimehighWord = word(packetBuffer[40], packetBuffer[41]);
    unsigned ntpsendTimelowWord = word(packetBuffer[42], packetBuffer[43]);
    unsigned ntpsendTimeMicrohighWord = word(packetBuffer[44], packetBuffer[45]);
    unsigned ntpsendTimeMicrolowWord = word(packetBuffer[46], packetBuffer[47]);
    unsigned long long ntpsendTime = (static_cast<unsigned long long>(ntpsendTimehighWord) << 48) | (static_cast<unsigned long long>(ntpsendTimelowWord) << 32) | (static_cast<unsigned long long>(ntpsendTimeMicrohighWord) << 16) | ntpsendTimeMicrolowWord;
    unsigned long long ntpserverspendTime = ntpsendTime - ntpgetTime;

    unsigned long long totalroadtime = (timegetudp - timesendudp);           //总路程时间
    totalroadtime = (totalroadtime << 32) / 1000000;                         //总路程时间毫秒
    unsigned long long roadtime = (totalroadtime - ntpserverspendTime) / 2;  //单程时间
    unsigned long long deviceGetTime = ntpsendTime + roadtime;               //设备得到UDP包时间16进制
    struct timeval tv;                                                       //创造一个结构体用于重置内部RTC
    tv.tv_sec = 0;                                                           //定义当前时刻为0时0分0秒 也就是说对时时刻为纪元原点 对时136年后时间戳溢出
    unsigned long long microtimenow = micros() + 63;                         //63位最后的计算补时即下7行代码需要消耗63微秒时间
    if (microtimenow < timegetudp) { return; }                               //如果微妙时间戳恰好溢出则对时失败
    unsigned long long calculationTime = (microtimenow - timegetudp);        //计算耗时
    calculationTime = (calculationTime << 32) / 1000000;                     //计算耗时微秒
    unsigned long long devicesetTime = deviceGetTime + calculationTime;      //计算当前时间戳
    unsigned long long microtime = (devicesetTime & 0xFFFFFFFF);             //计算当前时间秒小数
    microtime = (microtime * 1000000) >> 32;                                 //计算当前时间微秒秒数
    tv.tv_usec = microtime;                                                  //设置毫秒数
    settimeofday(&tv, NULL);                                                 //RTC对时
    unsigned long long ErastartTime = (static_cast<unsigned long long>(Era) << 32) | (devicesetTime >> 32);
    ntpTime = ErastartTime;
    // Serial.println(ErastartTime);
    // Serial.println("纪元开始时间");//正确
    // Serial.println(microtime);
    // Serial.println("纪元开始微秒");//正确

    // 保存 NTP 时间
    ntpTime -= 2208988800ULL;  // 从 1900 年转换为 Unix 时间戳
    // ntpTime += timeZone * 3600; // 考虑时区偏移
    // ntpTime *= 1000; // 转换为毫秒
    // Serial.println(ntpTime);
    // 更新全局变量
    // ntpTime = ntpTime;
    needupadte = 0;
  }
}

void setup() {
  // put your setup code here, to run once:
  Serial.begin(115200);
  WiFi.begin("S23", "12345678");
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting to WiFi...");
  }


  udp.listen(localPort);
  udp.onPacket([](AsyncUDPPacket packet) {
    // 处理接收到的 UDP 数据包
    handleNtpResponse(packet);
  });
  //HTTPS_GETTIME("openapi.alipay.com", "/gateway.do?method=alipay.trade.query", 443, 1024);  //乱请求根据响应头的内容获得时间
}




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

  //  HTTPS_request(String host, String url, int Port = 443, int Receive_cache = 1024)
  //  HTTPS_request("openapi.alipay.com","/gateway.do?biz_content=%7B%22out_trade_no%22%3A%22202108230101010012b%22%7D&app_id=2021001194613478&version=1.0&format=json&sign_type=RSA2&method=alipay.trade.query&timestamp=2023-06-27+06%3A19%3A09&auth_token=&alipay_sdk=alipay-sdk-php-2020-04-15&terminal_type=&terminal_info=&prod_code=&notify_url=&charset=UTF-8&app_auth_token=&app_cert_sn=0fbfea6f1c396ed1ee67302f2d035201&alipay_root_cert_sn=687b59193f3f462dd5336e5abf83c5d8_02941eef3187dddf3d3b83462e1dfcf6&target_app_id=&sign=HoOkV2%2BeyCqsUunlknDHFbUy9aaDu%2FtA79kMH2nggOa4xiehi6z7LtngohCPBKX8Lb2ROgCZ%2BqWto39Q8Gbm%2B4bgeRwxcCmTEsDw4DcjkxJMxCQBO4IwWUvcvYGqkUGT2X1dRb7NOnb8jl8CM%2BfQxZzgR2UijCczCIQP3zMk27VNOCRyRFrVAWPPRwQPSS7hlEYhvngiLPkA5tj%2Bhh85KlvQRopQrUWaKmPqANwVYb73TsyEdybmPoyoteqAGuGIiPpLUgHX7JHM96AKFNWyctIBAOuaxU%2B9%2FeuV49stHlCbNsR0UggTeu7Sr0dKcTB3IVbnZUH8%2FoCRUYTwN707Gw%3D%3D",443,1024);
  //  HTTPS_request("openapi.alipay.com",alipaytradequery("123"),443,1024);
  // HTTPS_request("openapi.alipay.com","gateway.do?","?biz_content=%7B%22out_trade_no%22%3A%22202108230101010012b%22%7D&app_id=2021001194613478&version=1.0&format=json&sign_type=RSA2&method=alipay.trade.query&timestamp=2023-06-27+06%3A19%3A09&auth_token=&alipay_sdk=alipay-sdk-php-2020-04-15&terminal_type=&terminal_info=&prod_code=&notify_url=&charset=UTF-8&app_auth_token=&app_cert_sn=0fbfea6f1c396ed1ee67302f2d035201&alipay_root_cert_sn=687b59193f3f462dd5336e5abf83c5d8_02941eef3187dddf3d3b83462e1dfcf6&target_app_id=&sign=HoOkV2%2BeyCqsUunlknDHFbUy9aaDu%2FtA79kMH2nggOa4xiehi6z7LtngohCPBKX8Lb2ROgCZ%2BqWto39Q8Gbm%2B4bgeRwxcCmTEsDw4DcjkxJMxCQBO4IwWUvcvYGqkUGT2X1dRb7NOnb8jl8CM%2BfQxZzgR2UijCczCIQP3zMk27VNOCRyRFrVAWPPRwQPSS7hlEYhvngiLPkA5tj%2Bhh85KlvQRopQrUWaKmPqANwVYb73TsyEdybmPoyoteqAGuGIiPpLUgHX7JHM96AKFNWyctIBAOuaxU%2B9%2FeuV49stHlCbNsR0UggTeu7Sr0dKcTB3IVbnZUH8%2FoCRUYTwN707Gw%3D%3D");
  struct timeval tv;  //创造一个结构体用于重置内部RTC
  gettimeofday(&tv, NULL);
  if (tv.tv_sec > 864000) { needupadte = 1; }  //如果大于10天就申请授时 10天RTC与标准时间差最大约20S影响不大

  if (needupadte) {
    //HTTPS授时
    //HTTPS_GETTIME("openapi.alipay.com", "/gateway.do?method=alipay.trade.query", 443, 1024);  //乱请求根据响应头的内容获得时间
  }
  if (needupadte) {
    //NTP授时
    getNtpTimeAsync();
    delay(3000);
    Serial.println("等待授时");
  } else {
    Serial.println(getalipaytime());
    delay(3000);
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/472016
ArduinoHTTP请求 获取任意服务器的时间_asyncudp arduino

ArduinoHTTP请求获取任意服务器的时间_asyncudp arduino
