Serveur NTP sur ESP8266 : Heure précise sans Internet | Guide

Serveur NTP autonome sur ESP8266 : Assurer un temps précis sans dépendances externes

Lorsque les connexions internet sont peu fiables et que les serveurs NTP externes sont bloqués, une source locale de temps précis devient indispensable. Nous allons voir comment construire un serveur NTP autonome sur l'ESP8266 avec une précision à la microseconde, qui continue de tourner même sans accès internet constant.

Pourquoi les solutions standard sont insuffisantes

Les infrastructures modernes ne peuvent souvent pas accéder aux serveurs NTP mondiaux en raison de restrictions réseau et de politiques de liste blanche. Lorsque les sources de temps externes sont coupées, les horloges système dérivent et se désynchronisent, ce qui pose un gros problème pour :

• Les transactions financières
• La journalisation de sécurité
• Les systèmes de calcul distribués
• Les appareils IoT avec des besoins stricts en synchronisation temporelle

La solution ? Construire un serveur NTP local qui maintient un temps précis de manière autonome entre les synchronisations. L'ESP8266 est parfait : faible consommation, WiFi intégré et assez de puissance pour gérer les horodatages.

Architecture du système temporel

Le principal défi est de dépasser les limites de la bibliothèque standard de temps d'Arduino, qui ne suit que les secondes entières. NTP (RFC 5905) exige une précision à la microseconde. Voici notre classe personnalisée JbTime, qui corrige deux problèmes fondamentaux :

• Pas de support pour les fractions de seconde dans le temps système
• Accumulation de dérive entre les synchronisations

Son fonctionnement :

• Quand le temps arrive d'un serveur externe, il capture l'horodatage microseconde du processeur
• Chaque requête calcule le delta du moment de synchronisation à maintenant
• La correction prend en compte le délai réseau avec cette formule : offset = ((t2 - t1) + (t3 - t4)) / 2

#ifndef jb_time
#define jb_time

#include <stdint.h>

#define JB_TIME_MAX_AGE  600

class JbTime {
private:
  uint64_t _last;
  uint64_t _sec;
  uint32_t _usec;
  uint32_t _mark;

public:
  bool ok;
  bool fresh;

  JbTime(){
    _sec = 0;
    _usec = 0;
    _mark = 0;
    _last = 0;
    ok = false;
    fresh = false;
  }

  inline bool old() {
    if(_sec == 0) return true;
    if((_sec - _last) > JB_TIME_MAX_AGE) return true;
    return false;
  }

  inline void settime(uint64_t sec, uint32_t usec, uint32_t mark = micros()){
    _mark = mark;
    _sec = sec;
    _sec += usec / 1000000;
    _usec = usec % 1000000;
    ok = true;
    _last = sec;
  }

  inline void gettime(uint64_t *o_sec, uint32_t *o_usec){
    if(ok){
      uint32_t now = micros();
      uint32_t delta = now - _mark;
      _mark = now;

      uint64_t total = (uint64_t)_usec + delta;
      _sec += total / 1000000;
      _usec = total % 1000000;

      *o_sec = _sec;
      *o_usec = _usec;
    } else {
      *o_sec = 0;
      *o_usec = 0;
    }
  }
};
#endif

Gestion des requêtes NTP

Le protocole NTP fonctionne sur le port UDP 123 et envoie le temps sous forme de valeur 64 bits (32 bits secondes, 32 bits fractions). La partie la plus délicate ? Compenser le délai réseau. Voici l'algorithme :

• Le client envoie la requête avec l'horodatage T1 (son heure locale)
• Le serveur reçoit à T2, envoie la réponse à T3
• Le client reçoit la réponse à T4
• Décalage : offset = ((T2 - T1) + (T3 - T4)) / 2

La classe JbNTPClient gère cela en tenant compte des particularités de l'ESP8266 :

• Paquets formatés selon RFC 5905
• Ajustement automatique de l'époque (NTP commence en 1900, Unix en 1970)
• Filtrage des réponses incorrectes

bool JbNTPClient::requestTime(const char* server, JbTime * mytime) {
  // ... initialization
  
  // Calculation T1
  uint64_t t1_sec = 0;
  uint32_t t1_usec = 0;
  systime->gettime(&t1_sec, &t1_usec);
  t1_sec += NTP_UNIX_EPOCH_DIFF;
  
  // Sending request
  udp.beginPacket(timeServerIP, ntpPort);
  udp.write((uint8_t*)&packet, sizeof(NTPPacket));
  udp.endPacket();

  // Ozhidanie otveta with taymautom 2000 ms
  while (udp.parsePacket() == 0) {
    if (millis() > timeout) return false;
    delay(10);
  }

  // Raschet T4 and setevoy zaderzhki
  double t4 = ntpToDouble(t4_sec, t4_frac);
  _networkDelay = (t4 - t1) - (t3 - t2);
  double offset = ((t2 - t1) + (t3 - t4)) / 2;

  // Installation skorrektirovannogo vremeni
  mytime->settime(sec, usec, t4_mark);
  return true;
}

Côté serveur : Fournir l'heure sur le réseau local

Une fois synchronisé avec des serveurs externes, l'appareil devient une source NTP à part entière. Il gère les requêtes clients via la méthode serve() :

• Analyser le paquet UDP entrant
• Vérifier le mode (attend mode=3 — requête client)
• Construire la réponse avec l'heure actuelle de JbTime
• Prendre en compte le temps de traitement pour une précision maximale

Fonctionnalité clé : Horodatage capturé juste au moment de l'envoi de la réponse (T3) pour minimiser l'erreur. Contrairement aux options prêtes à l'emploi, il tire le temps directement d'un compteur haute résolution, en évitant les fonctions système grossières.

Fonctionnalités clés

• Autonomie : Maintient une précision de 20-30 microsecondes entre les synchronisations, même hors ligne pendant des heures
• Efficacité des ressources : L'ESP8266 consomme moins de 70 mA en activité, compatible avec les batteries
• Compatibilité : Conforme à RFC 5905, fonctionne avec n'importe quel client NTP dès la sortie de la boîte
• Flexibilité : Ajustez l'âge maximum des données (JB_TIME_MAX_AGE) selon vos besoins
• Tolérance aux pannes : Basculment automatique vers les sauvegardes si le principal est en panne

— Editorial Team