Affichage heure NTP

Bonjour,
Je suis sur mon projet de "thermomètre - horloge" et je me heurte à un problème. tout fonctionne sauf que l'heure affiché est le décalage du fuseau horaire (02:00 au début et pas l'heure réelle). Lorsque je test la "partie" NTP seule, tout fonctionne mais si je copie tout dans le même programme, il n'affiche pas la bonne heure. Dans le programme totale il y a :

  • Le paramétrage d'une IP fixe, avec un nom DNS précis
  • La gestion d'une sonde DHT22
  • La gestion du NTP
  • La gestion de l'écran ssd1360 (qui affiche bien les 2 paramètres ( Temp et Humidité - Heure)
/*
  Définition d'un nom d'hôte et d'une adresse IP fixe
  Thermomètre et Hydrométrie
  Affichage sur OLED SSD1306
  NTP

Copié sur :
https://RandomNerdTutorials.com/esp8266-nodemcu-set-custom-hostname-arduino/
  
*/

//Librairies
#include <ESP8266WiFi.h>
#include <Adafruit_SSD1306.h>
#include "DHT.h"
//****************Pour NTP**********
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
//**********************************

#define DHTPIN 14 // Digital pin connected to the DHT sensor
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321

//****************Pour NTP**********
// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");

//Week Days
String weekDays[7]={"Dimanche", "Lundi", "Mardi", "Mercredi", "Jeudi", "Vendredi", "Samedi"};

//Month names
String months[12]={"Janvier", "Fevrier", "Mars", "Avril", "Mai", "Juin", "Juillet", "Aout", "Septembre", "Octobre", "Novembre", "Decembre"};
//**********************************

// Définition de l'écran
#define nombreDePixelsEnLargeur 128         // Taille de l'écran OLED, en pixel, au niveau de sa largeur
#define nombreDePixelsEnHauteur 64          // Taille de l'écran OLED, en pixel, au niveau de sa hauteur
#define brocheResetOLED         -1          // Reset de l'OLED partagé avec l'Arduino (d'où la valeur à -1, et non un numéro de pin)
#define adresseI2CecranOLED     0x3C        // Adresse de "mon" écran OLED sur le bus i2c (généralement égal à 0x3C ou 0x3D)

Adafruit_SSD1306 ecranOLED(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED);

// Définition du réseau
// Paramètre connexion Box (STATION)
const char* ssid     = "Nom SSID";
const char* password = "mon PWD";

// Nouveau nom d'hôte
String newHostname = "Therm_Bureau";

// Mettre une adresse IP fixe
IPAddress local_IP(192, 168, 1, 201);

// Gateway IP address
IPAddress gateway(192, 168, 1, 1);
IPAddress subnet(255, 255, 255, 0);

// Initialisation DHT sensor.
DHT dht(DHTPIN, DHTTYPE);
float Temperature;
float Humidity;

void setup() {
  
  // Pour l'écran de débogage
  Serial.begin(115200);

  // Réseau
  // WiFi.mode(WIFI_STA);
  //Obtenir le nom d'hôte
  Serial.printf("Default hostname: %s\n", WiFi.hostname().c_str());
  //Définir un nouveau nom d'hôte
  WiFi.hostname(newHostname.c_str());
  //Afficher le nouveau nom d'hôte
  Serial.printf("New hostname: %s\n", WiFi.hostname().c_str());
  // Configure l'IP fixe
  if (!WiFi.config(local_IP, gateway, subnet)) {
    Serial.println("STA Failed to configure");
  }
  
  //Initialise le Wi-Fi
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ..");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay(1000);
  }
  Serial.println(WiFi.localIP());
  Serial.print("RRSI: ");
  Serial.println(WiFi.RSSI());
  Serial.println(WiFi.hostname());

  // Initialisation de l'écran OLED
  if(!ecranOLED.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED))
    while(1);                               // Arrêt du programme (boucle infinie) si échec d'initialisation
  

  // Thermomètre
  pinMode(DHTPIN, INPUT);
  dht.begin();

  //****************Pour NTP**********
  // Initialize a NTPClient to get time
  timeClient.begin();
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 7200
  timeClient.setTimeOffset(7200);
  //**********************************


}



void loop() {

   ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer

  
  //****************Pour NTP**********
  timeClient.update();

  time_t epochTime = timeClient.getEpochTime();
  // Serial.print("Epoch Time: ");
  // Serial.println(epochTime);
  
  String formattedTime = timeClient.getFormattedTime();
  // Serial.print("Formatted Time: ");
  // Serial.println(formattedTime);  

  int currentHour = timeClient.getHours();
  // Serial.print("Hour: ");
  // Serial.println(currentHour);  

  int currentMinute = timeClient.getMinutes();
  // Serial.print("Minutes: ");
  // Serial.println(currentMinute); 
   
  int currentSecond = timeClient.getSeconds();
  //  Serial.print("Seconds: ");
  //  Serial.println(currentSecond);  

  String weekDay = weekDays[timeClient.getDay()];
  //  Serial.print("Week Day: ");
  //  Serial.println(weekDay);    

  //Get a time structure
  struct tm *ptm = gmtime ((time_t *)&epochTime); 

  int monthDay = ptm->tm_mday;
  //  Serial.print("Month day: ");
  //  Serial.println(monthDay);

  int currentMonth = ptm->tm_mon+1;
  //  Serial.print("Month: ");
  //  Serial.println(currentMonth);

  String currentMonthName = months[currentMonth-1];
  //  Serial.print("Month name: ");
  //  Serial.println(currentMonthName);

  int currentYear = ptm->tm_year+1900;
  //  Serial.print("Year: ");
  //  Serial.println(currentYear);

  //Print complete date:
  String currentDate = String(currentYear) + "-" + String(currentMonth) + "-" + String(monthDay);
  //  Serial.print("Current date: ");
  //  Serial.println(currentDate);
  //**********************************
  
  // Lecture de la température et de l'humidité Totes les 250 milliseconds!
  // Les lectures du capteur peuvent également être "anciennes" jusqu'à 10 secondes (c'est un capteur très lent)
  float h = dht.readHumidity();
  // Lire la température en degrés Celsius (valeur par défaut)
  float t = dht.readTemperature();
  // Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer).
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Calculer l'indice de chaleur en Celsius (Fahrenheit = faux)
  float hic = dht.computeHeatIndex(t, h, false);
  String affichage1 = "T:" + String (t,1) + "C";
  String affichage2 = "H:" + String (h,1) + "%";
  
  Serial.println(affichage1);
  Serial.println(affichage2);

 // *************************************************************************
  //for(byte tailleDeCaractere=1; tailleDeCaractere <=3; tailleDeCaractere++) {
  //  boolean bCouleurInverse = false;
    ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer
    byte tailleDeCaractere=3;
    ecranOLED.setTextSize(tailleDeCaractere);                   // Taille des caractères (3:1)
    ecranOLED.setCursor(0, 0);                                  // Déplacement du curseur en position (0,0), c'est à dire dans l'angle supérieur gauche
    ecranOLED.setTextColor(SSD1306_BLACK, SSD1306_WHITE);
    ecranOLED.setTextColor(SSD1306_WHITE);                  // Affichage du texte en "blanc" (avec la couleur principale, en fait, car l'écran monochrome peut être coloré)
    ecranOLED.setCursor(0, 5);
    ecranOLED.println(affichage1) ;
    ecranOLED.print(affichage2) ;
    ecranOLED.display();                            // Transfert le buffer à l'écran
    delay(10000);

    //****************Pour NTP**********
    // Serial.println("");
    ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer
    ecranOLED.setTextSize(4);
    ecranOLED.setTextColor(WHITE);
    ecranOLED.setCursor(0, 10);
    // Display static text au format HH:MM
    String formattedTime2 = formattedTime.substring(0, 5);
    ecranOLED.println(formattedTime2);
    ecranOLED.display();
    delay(10000);
    //**********************************

  
}
void handle_OnConnect() {
  Temperature = dht.readTemperature(); // Gets the values of the temperature
  Humidity = dht.readHumidity(); // Gets the values of the humidity 


 

}

Je pense que le problème viendrait de mon paramétrage IP fixe ...

Merci pour vos lumières.

Bonjour @degphi
Je vous ai fait un petit programme qui fonctionne avec la librairie time.h.
L’heure unix est utilisée. La date et l'heure sont affichées dans le moniteur série.

  • Petite explication sur time.h :

time_t : variable qui permet de mémoriser la valeur temporel selon le système de l'époque Unix : nombre de secondes écoulées depuis le 1er janvier 1970.
time_t maintenant;

struct tm : type de structure déclarant des définitions pour les différents membres d'une valeur temporelle :

struct tm {
   int tm_sec;         /* seconde de minute 0 à 59          */
   int tm_min;         /* minutes  0 à 59          */
   int tm_hour;        /* heure  0 à 23             */
   int tm_mday;        /* jour du mois  1 à 31  */
   int tm_mon;         /* mois  0 à 11             */
   int tm_year;        /* années depuis 1900   */
   int tm_wday;        /* jours depuis dimanche   0 à 6    */
   int tm_yday;        /* jours depuis le 1er janvier , 0 à 365  */
   int tm_isdst;       /* drapeau Daylight (heure d'hiver)             */
};

struct tm * timeinfo; dans le programme.

La fonction time() récupère l'adresse de la variable time_t et la remplit avec le temps en époque unix.
time(&maintenant);

localtime() remplit la variable timeinfo conforme à la tructure tm à partir de la valeur temporelle qu'elle trouve dans la variable time_t c'est à dire maintenant. Elle renvoie ensuite l'adresse de la structure tm renseignée.
timeinfo = localtime(&maintenant); (dans la fonction afficheHeureDate()).

Vous n’avez qu’à l’intégrer à votre programme après l’avoir essayé.

#include <ESP8266WiFi.h>
#include "time.h"
const char* ssid       = "   ";
const char* password   = "    ";
const int decalage = 2;  // 2 - heure d'été, 1 pour l'hiver
const int delaiDemande = 30; // nombre de secondes entre deux demandes consécutives au serveur NTP
unsigned long derniereDemande = millis(); // moment de la plus récente demande au serveur NTP
unsigned long derniereMaJ = millis(); // moment de la plus récente mise à jour de l'affichage de l'heure

time_t maintenant;
struct tm * timeinfo;

void setup() {
  Serial.begin(115200);
  //Paramétrage WIFI
  WiFi.mode(WIFI_STA);
  Serial.println();
  WiFi.begin(ssid, password);
  Serial.print("Connexion au reseau WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    Serial.print(".");
    delay(1000);
  }
  Serial.println();


  // serveur NTP
  configTime(decalage * 3600, 0, "fr.pool.ntp.org"); // fonction fournie par time.h
  Serial.print("Attente date et heure");
  while (time(nullptr) <= 100000) {
    Serial.print(".");
    delay(1000);
  }
  time(&maintenant);
  Serial.println("");

}

void loop() {
  // est-ce le moment de demander l'heure NTP?
  if ((millis() - derniereDemande) >=  delaiDemande * 1000 ) {
    time(&maintenant);
    derniereDemande = millis();

    Serial.println("Interrogation du serveur NTP");
  }

  // est-ce le moment de raffraichir la date indiquée?
  if ((millis() - derniereMaJ) >=   1000 ) {
    maintenant = maintenant + 1;  // on ajoute une seconde
    afficheHeureDate();
    derniereMaJ = millis();
    Serial.println("Affichage de l'heure");
  }
  // Affichage de l'heure toutes les secondes

}

void afficheHeureDate() {

  timeinfo = localtime(&maintenant);

  Serial.print("Date: ");

  if (timeinfo->tm_mday < 10) {
    Serial.print("0");
  }

  Serial.print(timeinfo->tm_mday);  // timeinfo->tm_mday: jour du mois (1 - 31)
  Serial.print("-");

  if ((timeinfo->tm_mon + 1) < 10) {
    Serial.print("0");
  }

  Serial.print(timeinfo->tm_mon + 1);    // timeinfo->tm_mon: mois (0 - 11, 0 correspond à janvier)
  Serial.print("-");
  Serial.print(timeinfo->tm_year + 1900);  // timeinfo->tm_year: tm_year nombre d'années écoulées depuis 1900


  Serial.print(" Heure: ");
  if ((timeinfo->tm_hour ) < 10) {
    Serial.print("0");
  }
  Serial.print(timeinfo->tm_hour );  // heure entre 0 et 23
  Serial.print(":");
  if (timeinfo->tm_min < 10) {
    Serial.print("0");
  }
  Serial.print(timeinfo->tm_min);   // timeinfo->tm_min: minutes (0 - 59)
  Serial.print(":");

  if (timeinfo->tm_sec < 10) {
    Serial.print("0");
  }
  Serial.println(timeinfo->tm_sec);   // timeinfo->tm_sec: secondes (0 - 60)



}

Voilà bonne journée

PS : Ce programme fonctionne sur esp32, il vous suffit de changer #include <ESP8266WiFi.h> par
#include <WiFi.h>

Bonjour @philippe86220

Merci pour cette réponse rapide :+1:
Il ne me reste plus qu'à essayer dans mon programme et voir le résultat !

Bonne journée à tous.

Sur ESP8266 et ESP32 la fonction configTzTime() permet de tenir compte du fuseau horaire et des changements d'heure été / hiver.

#include <Arduino.h>
#ifdef ESP32
#include <WiFi.h>
#else
#include <ESP8266WiFi.h>
#endif

#define MAX_SIZE 80

const char *ssid = "sssssssssssss";
const char *password = "pppppppppppppp";

const char* ntpServer = "pool.ntp.org";

void setup() {
  Serial.begin(115200);
  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    Serial.print('.');
    delay (500);
  }
  configTzTime("CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00", ntpServer);
}

void loop() {
  time_t timestamp = time( NULL );
  char buffer[MAX_SIZE];
  struct tm *pTime = localtime(&timestamp );
  strftime(buffer, MAX_SIZE, "%d/%m/%Y %H:%M:%S", pTime);
  Serial.println(buffer);
  delay(1000);
}

La chaîne de caractères "CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00" est une "timezone string".

Avec cette configuration le changement d'heure sera donc automatique le dernier dimanche de mars à 2:00 et octobre à 3:00.

Les explications ici : https://www.di-mgt.com.au/wclock/tz.html

Une documentation à lire : System Time - ESP32 - — ESP-IDF Programming Guide latest documentation

1 Like

Merci @hbachetti, je ne connaissais pas cette fonction.
C'est bien plus simple comme ça.

Merci et bonne journée.

En cas de besoin j'ai écrit une librairie permettant de faire à peu près la même chose avec ARDUINO+Ethernet :
https://bitbucket.org/henri_bachetti/w5100-ntp.git

Voili voilou

J'irai y jeter un œil :wink:
Merci.

Merci @hbachetti
Oui cela a l'air plus simple comme mise en route ...

Bonjour à tous;
Je remonte le résultat du programme proposé par @hbachetti intégré dans le mien, ça ne fonctionne pas. Il affiche la première fois :
192.168.1.201
RRSI: -59
Therm_Bureau
T:22.2C
H:69.0%
01/01/1970 01:00:14
J'ai l'impression que mon paramétrage réseau met la pagaille ! Pourtant j'ai bien une adresse IP valide sur mon réseau. Mon matériel répond bien au Ping.
Puis-je avoir la certitude que mon Arduino est bien connecté à Internet ? Au serveur NTP ?Par un ping par exemple ...
Si vous le voulez, je peux donner le programme modifié par mes soins.
Merci encore pour vos idées.
Bon dimanche.

Il est probable que la première fois, le serveur NTP n'a pas encore été contacté. La lecture de l'heure est faite trop tôt.

  time_t timestamp = time( NULL );

Le 01/01/1970 correspond à un timeStamp égal à ZERO. Il est donc facile d'ignorer cette valeur à l'aide d'un simple test :

  time_t timestamp = time( NULL );
  if (timestamp != 0) {
    char buffer[MAX_SIZE];
    struct tm *pTime = localtime(&timestamp );
    strftime(buffer, MAX_SIZE, "%d/%m/%Y %H:%M:%S", pTime);
    Serial.println(buffer);
  }

Si tu veux être sûre de l'accès à l'extérieur de ton réseau local, tu peux essayer une connexion avec WifiClient sur les serveurs de google par exemple ou de forum.arduino.cc :slight_smile:

  WiFiClient client;
  const int httpPort = 80;
  if (!client.connect(host, httpPort)) {
    Serial.println("connection failed");
    return;
  }

Mais comme le dit @hbachetti, la réponse du NTP, n'a pas encore dû être faite.

Merci @terwal pour ton petit programme. Le problème vient bien de ma connexion IP. Je vois bien mon Arduino sur le réseau (IP 192.168.1.201) mais j'ai une "connetion failed". Là, j'y perd mon latin (ou mon langage C :wink: )

Là on sort du sujet. Une erreur de connexion sur un serveur Google peut très bien provenir d'un mauvais choix (URL, port, http/https, etc.).

Donc l'accès au serveur NTP est possible.
Il faut simplement attendre que la fonction time() retourne une valeur différente de ZÉRO.
En d'autres termes, si time() retourne ZÉRO, tu ne fais rien, sinon tu affiches l'heure.

@degphi
Il faut essayer le programme de @hbachetti post #4 seul et voir si tout fonctionne correctement. Ensuite il faudra voir si vous l'avez bien intégré dans votre programme.

Pour ma part, j'ai modifié un de mes programmes dans lequel je récupère l'heure NTP selon les directives de @hbachetti dans son message #4 et tout fonctionne parfaitement.

Je me suis amusé à utiliser un petit programme qui affichait sur un écran SSD1306 l'heure NTP. Là ça fonctionne … Voici mon petit programme :

/*
  affichage heure et minute via serveur NTP
*/

#include <ESP8266WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

#define SCREEN_WIDTH 128 // OLED display width, in pixels
#define SCREEN_HEIGHT 64 // OLED display height, in pixels

// Declaration for an SSD1306 display connected to I2C (SDA, SCL pins)
Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, -1);


// Replace with your network credentials
const char* ssid     = "";
const char* password = "";

// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");


void setup() {
  // Initialize Serial Monitor
  Serial.begin(115200);

  if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) { // Address 0x3D for 128x64
    Serial.println(F("SSD1306 allocation failed"));
    for(;;);
  }
  delay(2000);
  display.clearDisplay();
  
  // Connect to Wi-Fi
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

// Initialize a NTPClient to get time
  timeClient.begin();
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 0
  timeClient.setTimeOffset(7200);
}

void loop() {
  timeClient.update();

  time_t epochTime = timeClient.getEpochTime();
//  Serial.print("Epoch Time: ");
//  Serial.println(epochTime);
  
  String formattedTime = timeClient.getFormattedTime();
//  Serial.print("Formatted Time: ");
//  Serial.println(formattedTime);  

  //Get a time structure
  struct tm *ptm = gmtime ((time_t *)&epochTime); 


 display.clearDisplay();

  display.setTextSize(4);
  display.setTextColor(WHITE);
  display.setCursor(0, 10);
  // Display static text au format HH:MM
  String formattedTime2 = formattedTime.substring(0, 5);
  display.println(formattedTime2);
  display.display(); 

  delay(10000);
}

Mais dès que je l'intègre à mon programme (celui du début) cela ne marche pas. Il y a une configuration réseau qui bloque la sortie sur Internet. Dans la configuration, je voulais le choix de l'adresse IP et du Hostname … Je ne vois pas de solution, désolé.

Essayez celui de @hbachetti ça doit fonctionner.

essayez le seul.

Bonsoir,

J'avais pas testé cette condition et il semble qu'elle soit toujours

!= 0

car timeStamp égal à ZERO correspond au 01/01/1970 à 01:00:00 et non pas 00:00:00.

Peut être à cause de
configTzTime("CET-1CEST-2,M3.5.0/02:00:00,M10.5.0/03:00:00", ntpServer);

Je verrai ça demain ou après demain ...

Bonne soirée

Faut lire les .h

update retourne un booléen qui indique le succès ou l'échec de la requête.

Bonjour à tous.

Déjà, merci pour vos idées. C'est un site très réactif !

Pour mon problème, c'était bien un problème réseau. Lorsque je changeais les paramètres réseaux, l'Arduino perdait la possibilité de sortir du réseau local !!! C'est un problème qui arrive (souvent) avec les box Orange. J'ai donc repris mon ancien programme et j'y ai rajouté ... Un "WiFi.disconnect();" pour enlever tout ce qui "traine" avant la configuration. Et là ça fonctionne. Je vous donne mon programme modifié :

/*
  Définition d'un nom d'hôte et d'une adresse IP fixe
  Thermomètre et Hydrométrie
  Affichage sur OLED SSD1306
  Heure NTP
 Affichage en alternance de" la Th et Hum" puis "Heure NTP" toutes les 10 secondes

Copié sur :
https://RandomNerdTutorials.com/esp8266-nodemcu-set-custom-hostname-arduino/
  
*/

// Librairies
#include <ESP8266WiFi.h>
#include <Adafruit_SSD1306.h>
#include "DHT.h"
//****************Pour NTP**********
#include <NTPClient.h>
#include <WiFiUdp.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
//**********************************

//**************Pour DHT************
#define DHTPIN 14 // Digital pin connected to the DHT sensor
#define DHTTYPE DHT22   // DHT 22  (AM2302), AM2321
//**********************************

//****************Pour NTP**********
// Define NTP Client to get time
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");
//**********************************

// Définition de l'écran
#define nombreDePixelsEnLargeur 128         // Taille de l'écran OLED, en pixel, au niveau de sa largeur
#define nombreDePixelsEnHauteur 64          // Taille de l'écran OLED, en pixel, au niveau de sa hauteur
#define brocheResetOLED         -1          // Reset de l'OLED partagé avec l'Arduino (d'où la valeur à -1, et non un numéro de pin)
#define adresseI2CecranOLED     0x3C        // Adresse de "mon" écran OLED sur le bus i2c (généralement égal à 0x3C ou 0x3D)

Adafruit_SSD1306 ecranOLED(nombreDePixelsEnLargeur, nombreDePixelsEnHauteur, &Wire, brocheResetOLED);

// Définition du réseau
// Paramètre connexion Box (STATION)
const char* ssid     = "SSSSSSSSSSS";
const char* password = "MdP";

// Configuration IP Statique et Host
IPAddress staticIP787_201(192,168,1,201);
IPAddress gateway787_201(192,168,1,1);
IPAddress subnet787_201(255,255,255,0);

// Initialisation DHT sensor.
DHT dht(DHTPIN, DHTTYPE);
float Temperature;
float Humidity;

void setup() {
  
  // Pour l'écran de débogage
  Serial.begin(115200);
  WiFi.disconnect();
  delay(3000);

  //Initialise le Wi-Fi
  WiFi.begin(ssid, password);
   Serial.println("Début du programme pour réseau");
    while ((!(WiFi.status() == WL_CONNECTED))){
    delay(300);
  }
  WiFi.config(staticIP787_201, gateway787_201, subnet787_201);
  WiFi.hostname("Th_bureau") ;
  Serial.println("Connecté");
  Serial.print("L'adresse IP est : ");
  Serial.println((WiFi.localIP().toString()));
  Serial.print("Le masque est :");
  Serial.println((WiFi.subnetMask().toString().c_str()));
  Serial.print("La passerelle est :");
  Serial.println((WiFi.gatewayIP().toString().c_str()));
  Serial.print("Le nom d\'hôte est :");
  Serial.println((WiFi.hostname()));

  // Initialisation de l'écran OLED
  if(!ecranOLED.begin(SSD1306_SWITCHCAPVCC, adresseI2CecranOLED))
    while(1);                               // Arrêt du programme (boucle infinie) si échec d'initialisation
  

  // Thermomètre
  pinMode(DHTPIN, INPUT);
  dht.begin();

  //****************Pour NTP**********
  // Initialize a NTPClient to get time
  timeClient.begin();
  // Set offset time in seconds to adjust for your timezone, for example:
  // GMT Paris = 7200
  timeClient.setTimeOffset(7200);
  //**********************************
}

void loop() {

   ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer

  //****************Pour NTP**********
  timeClient.update();  
  String formattedTime = timeClient.getFormattedTime();
  // Serial.print("Formatted Time: ");
  // Serial.println(formattedTime);
  //**********************************
  
  // Lecture de la température et de l'humidité Totes les 10 seconds!
  // Les lectures du capteur peuvent également être "anciennes" jusqu'à 10 secondes (c'est un capteur très lent)
  float h = dht.readHumidity();
  // Lire la température en degrés Celsius (valeur par défaut)
  float t = dht.readTemperature();
  // Vérifiez si des lectures ont échoué et quittez plus tôt (pour réessayer).
  if (isnan(h) || isnan(t)) {
    Serial.println(F("Failed to read from DHT sensor!"));
    return;
  }

  // Calculer l'indice de chaleur en Celsius (Fahrenheit = faux)
  float hic = dht.computeHeatIndex(t, h, false);
  String affichage1 = "T:" + String (t,1) + "C";
  String affichage2 = "H:" + String (h,1) + "%";
  
  Serial.println(affichage1);
  Serial.println(affichage2);

  // ***Pour Thermomètre et Humidité***
    ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer
    byte tailleDeCaractere=3;
    ecranOLED.setTextSize(tailleDeCaractere);                   // Taille des caractères (3:1)
    ecranOLED.setCursor(0, 0);                                  // Déplacement du curseur en position (0,0), c'est à dire dans l'angle supérieur gauche
    ecranOLED.setTextColor(SSD1306_BLACK, SSD1306_WHITE);
    ecranOLED.setTextColor(SSD1306_WHITE);                  // Affichage du texte en "blanc" (avec la couleur principale, en fait, car l'écran monochrome peut être coloré)
    ecranOLED.setCursor(0, 5);
    ecranOLED.println(affichage1) ;
    ecranOLED.print(affichage2) ;
    ecranOLED.display();                            // Transfert le buffer à l'écran
    delay(10000);

    //****************Pour NTP**********
    ecranOLED.clearDisplay();                                   // Effaçage de l'intégralité du buffer
    ecranOLED.setTextSize(4);
    ecranOLED.setTextColor(WHITE);
    ecranOLED.setCursor(0, 10);
    // Display static text au format HH:MM
    String formattedTime2 = formattedTime.substring(0, 5);
    ecranOLED.println(formattedTime2);
    ecranOLED.display();
    Serial.println(formattedTime2);
    delay(10000);
    //**********************************
}

void handle_OnConnect() {
  Temperature = dht.readTemperature(); // Gets the values of the temperature
  Humidity = dht.readHumidity(); // Gets the values of the humidity 
}

J'espère que cela va pouvoir servir à d'autre utilisateur.
Merci encore pour votre patience.
Bonne semaine à tous.
Cordialement.

Degphi