C++ ESP32 Internet Clock

Mit diesem Programm wird das Datum und die Uhrzeit aus dem Internet von einem NTP Server abgefragt und an einem OLED-Display 1,3" angezeigt.

Hardware

Die Hardware für die Internet Clock

• 1 x ESP32
• 1 x OLED Display 1,3"

Programm

C++ ESP32 ntp-Server Test-Programm 1, Datum und Zeit auslesen

#include "time.h"

const char* ssid       = "xxx";
const char* password   = "xxx";

const char* ntpServer = "de.pool.ntp.org";
const long  gmtOffset_sec = 3600;
const int   daylightOffset_sec = 3600;
int second;
int minute;
int hour;
int day;
int month;
int year;
int weekday;
long current;
struct tm timeinfo;


/*
struct tm
{
int    tm_sec;   //   Seconds [0,60].
int    tm_min;   //   Minutes [0,59].
int    tm_hour;  //   Hour [0,23].
int    tm_mday;  //   Day of month [1,31].
int    tm_mon;   //   Month of year [0,11].
int    tm_year;  //   Years since 1900.
int    tm_wday;  //   Day of week [0,6] (Sunday =0).
int    tm_yday;  //   Day of year [0,365].
int    tm_isdst; //   Daylight Savings flag.
}

*/

void printLocalTime()
{

  if(!getLocalTime(&timeinfo)){
    Serial.println("Es konnte keine Zeit ermittelt werden");
    return;
  }
  Serial.print("Ausgelesenes Datum vom ntpServer:  ");
  Serial.println(&timeinfo, "%A, %d %B %Y %H:%M:%S");
}

void setup()
{
  Serial.begin(115200);

  //WiFi Verbindung
  Serial.printf("Verbunden mit %s ", ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
      delay(500);
      Serial.print(".");
  }
  Serial.println(" CONNECTED");

  //init Datum Zeit
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  printLocalTime();

  //WiFi trennen, wenn es nicht mehr benötigt wird
  WiFi.disconnect(true);
  WiFi.mode(WIFI_OFF);
}

void loop()
{
  delay(3000);

  printLocalTime();
  second = timeinfo.tm_sec;
  minute = timeinfo.tm_min;
  hour = timeinfo.tm_hour; //Sommerzeit Korrktur: hour = timeinfo.tm_hour - 1;
  day = timeinfo.tm_mday;
  month = timeinfo.tm_mon + 1;
  year = timeinfo.tm_year + 1900;
  weekday = timeinfo.tm_wday + 1;
  Serial.print("Datum von den korrigierten Variablen:  ");
  Serial.print(day);
  Serial.print(".");
  Serial.print(month);
  Serial.print(".");
  Serial.print(year);
  Serial.print(" - ");
  Serial.print(hour);
  Serial.print(":");
  Serial.print(minute);
  Serial.print(":");
  Serial.print(second);
  Serial.println(" Uhr");
  Serial.println();
}

RAW code

C++ ESP32 ntp-Server Test-Programm 2, Datum und Zeit auslesen

#include <NTPClient.h>
#include <WiFiUdp.h>

const char *ssid     = "xxx";
const char *password = "xxx";

//Zeitverschiebung UTC <-> MEZ (Winterzeit) = 3600 Sekunden (1 Stunde)
//Zeitverschiebung UTC <-> MEZ (Sommerzeit) = 7200 Sekunden (2 Stunden)
const long utcOffsetInSeconds = 3600;


char daysOfTheWeek[7][12] = {"Sonntag", "Montag", "Dienstag", "Mittwoch", "Donnerstag", "Freitag", "Samstag"};

WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org", utcOffsetInSeconds);

void setup(){
  Serial.begin(115200);

  WiFi.begin(ssid, password);

  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Ich verbinde mich mit dem Internet...");
  }

  Serial.println("Ich bin mit dem Internet verbunden!");

  timeClient.begin();
}

void loop() {
  timeClient.update();

  Serial.print(daysOfTheWeek[timeClient.getDay()]);
  Serial.print(", ");
  Serial.println(timeClient.getFormattedTime());

  delay(1000);
}

RAW code

C++ ESP32 ntp-Server Test-Programm 3, formatierte Anzeige

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: NTP ZEit mit formatierter Ausgabe

**************************************************************************************************
Version: 22.06.2022
**************************************************************************************************
Board: ESP32vn IoT UNO
**************************************************************************************************
Libraries:
https://github.com/espressif/arduino-esp32/tree/master/libraries
C:\Users\User\Documents\Arduino
D:\gittemp\Arduino II\A156_Wetterdaten_V3
**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
http://arduino.esp8266.com/stable/package_esp8266com_index.json
**************************************************************************************************/
//#include <ESP8266WiFi.h>
#include <WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>

//Hier muss die SSID & das Passwort des WLAN Netzwerkes eingetragen werden
const char* ssid     = "xxx";
const char* password = "xxx";
WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP, "pool.ntp.org");

char* wochentage[7]={"Sonntag", "Montag", "Dienstag", "Mitwoch", "Donnerstag", "Freitag", "Samstag"};

void setup() {
  //beginn der seriellen Kommunikation mit 9600baud
  Serial.begin(115200);

  Serial.print("Verbinde mit ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi verbunden.");
  Serial.println("IP Addresse: ");
  Serial.println(WiFi.localIP());

  //initialisieren des NTPClients um die Zeit auszulesen
  timeClient.begin();
  //Offset in Sekunden zur GMT +/- 0 Zeitzone
  //Für Deutschland muss man 1h = 3600 Sekunden nehmen,
  //je nach Sommer- /Winterzeit muss noch zusätzlich eine 1h (also 3600 Sekunden)
  //auf diese Zeit draufaddiert werden.
  timeClient.setTimeOffset(7200);
}

void loop() {
  //aktualisieren des Zeitstempels
  timeClient.update();

  //Zeitstempel auf der Sekunde genau
  //(Nicht zuverwechseln mit dem UNIX Timestamp welcher auf die Millisekunde genau ist.)
  unsigned long epochTime = timeClient.getEpochTime();
  Serial.print("Epoch Time: ");
  Serial.println(epochTime);

  //Ausgabe des formatierten Zeitstempels
  String formattedTime = timeClient.getFormattedTime();
//  Serial.print("formatierter Zeitstempel: ");
//  Serial.println(formattedTime);

  //einzelne Werte der Uhrzeit lesen
  int aktuellerTag = timeClient.getDay();
  /*
  int aktuelleStunde = timeClient.getHours();
  int aktuelleMinute = timeClient.getMinutes();
  int aktuelleSekunde = timeClient.getSeconds();
  */
  delay(100);

  //reservieren eines char Arrays mit maximal 20 Zeichen
  char timestamp[20];

  //Formatieren der Werte in einen String
  sprintf(timestamp,"Heute ist %s",wochentage[aktuellerTag]);
  //Ausgeben des Formatierten Strings auf der seriellen Schnittstelle
    Serial.print(timestamp);
    Serial.print(" ");
    Serial.println(formattedTime);

  delay(5000);
}

RAW code

C++ Analoguhr am OLED Display anzeigen"

/*
PROGRAMMINFO

Funktion: Analoguhr am OLED Display anzeigen
Version: 09.03.2021

() C++ Arduino IDE V1.8.13


Board: ESP32)

Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json

 */

#include <Arduino.h>
#ifdef ESP32
  #include <WiFi.h>
#else
  #include <ESP8266WiFi.h>
#endif
#include <time.h>
#include <SPI.h>
#include <Wire.h>
#include <Adafruit_GFX.h>
#include <Adafruit_SSD1306.h>

Adafruit_SSD1306 display = Adafruit_SSD1306(128, 64, &Wire, -1);

const char* ssid = "xxx";
const char* password = "xxx";

int GMTOffset = 7200;  //Replace with your GMT Offset in seconds
int daylightOffset = 0;  //Replace with your daylight savings offset in seconds

void setup() {
Serial.begin(115200);

if(!display.begin(SSD1306_SWITCHCAPVCC, 0x3C)) {
  Serial.println(F("SSD1306 allocation failed"));
  for(;;);
}
  delay(2000);
display.clearDisplay();
display.setTextSize(1);
display.setCursor(0,0);
display.setTextColor(WHITE);

WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(1000);
    Serial.println("Connecting...");
  }

  Serial.println("Connected to Wi-Fi!");

configTime(GMTOffset, daylightOffset, "de.pool.ntp.org","time.nist.gov");
}
void loop() {
time_t rawtime = time(nullptr);
struct tm* timeinfo = localtime(&rawtime);

int radius = 35;
display.drawCircle(display.width()/2, display.height()/2, 2, WHITE);
//draw clock
for( int i=0; i < 360;i= i + 30 ){
float angle = i ;
angle=(angle/57.29577951) ;
int x1=(64+(sin(angle)*radius));
int y1=(32-(cos(angle)*radius));
int x2=(64+(sin(angle)*(radius-5)));
int y2=(32-(cos(angle)*(radius-5)));
display.drawLine(x1,y1,x2,y2,WHITE);
}

//draw second hand
float angle = timeinfo->tm_sec*6 ;
angle=(angle/57.29577951) ;
int x2=(64+(sin(angle)*(radius)));
int y2=(32-(cos(angle)*(radius)));
display.drawLine(64,32,x2,y2,WHITE);

// draw minute hand
angle = timeinfo->tm_min * 6 ;
angle=(angle/57.29577951) ;
x2=(64+(sin(angle)*(radius-3)));
y2=(32-(cos(angle)*(radius-3)));
display.drawLine(64,32,x2,y2,WHITE);

// draw hour hand
angle = timeinfo->tm_hour * 30 + int((timeinfo->tm_min / 12) * 6 );
angle=(angle/57.29577951) ;
x2=(64+(sin(angle)*(radius-11)));
y2=(32-(cos(angle)*(radius-11)));
display.drawLine(64,32,x2,y2,WHITE);

display.display();
delay(100);
display.clearDisplay();

}

RAW code

Analoguhr am OLED Display

C++ ESP32 Internet Clock 1

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Internet Clock mit OLED Display 1,3"
**************************************************************************************************
Version: 17.03.2022
**************************************************************************************************
Board: ESP32vn IoT UNO V1.0.4
**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
Librarys
- WiFi.h V0.16.1
**************************************************************************************************

 **************************************************************************************************/

#include <WiFi.h>
#include <NTPClient.h>
#include <WiFiUdp.h>


const char* ssid     = "xxx";
const char* password = "xxx";


WiFiUDP ntpUDP;
NTPClient timeClient(ntpUDP);

// Variablen
String formattedDate;
String dayStamp;
String timeStamp;

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
unsigned long delayTime;

void setup() {

  Serial.begin(115200);
  u8g2.begin();

  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }

  Serial.println("");
  Serial.println("WiFi connected.");
  Serial.println("IP address: ");
  Serial.println(WiFi.localIP());

// NTPClient Zeit
  timeClient.begin();
  // Zeitzonen Offset
  // GMT +1 = 3600
  // GMT +8 = 28800
  // GMT -1 = -3600
  // GMT 0 = 0
  timeClient.setTimeOffset(3600);
}
void loop() {
  while(!timeClient.update()) {
    timeClient.forceUpdate();
  }
  // Eingehendes Format
  // 2018-05-28T16:00:13Z
  // Extrahiere Zeit und Datum
  formattedDate = timeClient.getFormattedDate();
  Serial.println(formattedDate);

  // Extrahiere Datum
  int splitT = formattedDate.indexOf("T");
  dayStamp = formattedDate.substring(0, splitT);
  Serial.print("Datum: ");
  Serial.println(dayStamp);
  // Extrahiere Zeit
  timeStamp = formattedDate.substring(splitT+1, formattedDate.length()-1);
  Serial.print("Uhrzeit: ");
  Serial.println(timeStamp);
  delay(1000);

Serial.println("=================================");
Serial.println("Internet Clock");

    u8g2.setFont(u8g2_font_courR10_tf);
    u8g2.firstPage();

    do {

      u8g2.setCursor(1, 10);
      u8g2.print("Internet Clock");
      //u8g2.setCursor(30, 22);
      //u8g2.print("Tegernsee");


u8g2.setFont(u8g2_font_courR14_tf);
      u8g2.setCursor(10, 35);
      u8g2.print(dayStamp);
      u8g2.setCursor(20, 55);
      u8g2.print(timeStamp);


      } while ( u8g2.nextPage() );
     delay(delayTime);
}

RAW code

Internet Clock 1 mit OLED-Display:

C++ ESP32 Internet Clock 2

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: ESP32 WInternet Clock mit OLED Display 1,3" V2
**************************************************************************************************
Version: 17.03.2022
**************************************************************************************************
Board: ESP32vn IoT UNO V1.0.4

**************************************************************************************************
C++ Arduino IDE V1.8.13
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
Librarys
- WiFi.h V0.16.1
**************************************************************************************************
OLED Schriftarten:
https://arduino-projekte.info/schriftarten-fuer-oled-display/#torussansbold8_8r

 **************************************************************************************************/
#include <WiFi.h>
#include "time.h"

const char* ssid     = "xxx";
const char* password = "xxx";

const char* ntpServer = "de.pool.ntp.org";
const long  gmtOffset_sec = 0;
const int   daylightOffset_sec = 7200;

#include <Arduino.h>
#include <U8g2lib.h>

#ifdef U8X8_HAVE_HW_SPI
#include <SPI.h>
#endif
#ifdef U8X8_HAVE_HW_I2C
#include <Wire.h>
#endif

U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
unsigned long delayTime;

void setup(){
  Serial.begin(115200);
    u8g2.begin();

  // Connect to Wi-Fi
  Serial.print("Connecting to ");
  Serial.println(ssid);
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("");
  Serial.println("WiFi connected.");

  // Init and get the time
  configTime(gmtOffset_sec, daylightOffset_sec, ntpServer);
  printLocalTime();

  //disconnect WiFi as it's no longer needed
  WiFi.disconnect(true);
  WiFi.mode(WIFI_OFF);
}

void loop(){
  delay(1000);
  printLocalTime();
}

void printLocalTime(){
  struct tm timeinfo;
  if(!getLocalTime(&timeinfo)){
    Serial.println("Failed to obtain time");
    return;
  }


  Serial.println(&timeinfo, "%A, %B %d %Y %H:%M:%S");
  Serial.print("Day of week: ");
  Serial.println(&timeinfo, "%A");
  Serial.print("Month: ");
  Serial.println(&timeinfo, "%B");
  Serial.print("Day of Month: ");
  Serial.println(&timeinfo, "%d");
  Serial.print("Year: ");
  Serial.println(&timeinfo, "%Y");
  Serial.print("Hour: ");
  Serial.println(&timeinfo, "%H");
//Serial.print("Hour (12 hour format): ");
//Serial.println(&timeinfo, "%I");
  Serial.print("Minute: ");
  Serial.println(&timeinfo, "%M");
  Serial.print("Second: ");
  Serial.println(&timeinfo, "%S");

  Serial.println();


Serial.println("=================================");
Serial.println("Internet Uhr");

    u8g2.setFont(u8g2_font_courB12_tf);
    u8g2.firstPage();

    do {

      u8g2.setCursor(10, 10);
      u8g2.print("Internet Clock");
      //u8g2.setCursor(30, 22);
      //u8g2.print("Tegernsee");


u8g2.setFont(u8g2_font_courR10_tf);
      u8g2.setCursor(10, 30);
      u8g2.print(&timeinfo, "%A");
      u8g2.setCursor(10, 45);
      u8g2.print(&timeinfo, "%d %B %Y");
      u8g2.setCursor(10, 60);
      u8g2.print(&timeinfo, "%H:%M:%S");

      } while ( u8g2.nextPage() );
     delay(delayTime);



}

RAW code

Internet Clock 2 mit OLED-Display:

C++ ESP32 Internet Clock 3

/*************************************************************************************************
                                      PROGRAMMINFO
**************************************************************************************************
Funktion: Funktion: ESP32 ntp Datum und Zeit Digitalanzeige OLED 1,3"
**************************************************************************************************
Version: 19.03.2022
**************************************************************************************************
Board: ESP32vn IoT UNO V1.0.4

**************************************************************************************************
C++ Arduino IDE V1.8.19
**************************************************************************************************
Einstellungen:
https://dl.espressif.com/dl/package_esp32_index.json
http://dan.drown.org/stm32duino/package_STM32duino_index.json
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.json
**************************************************************************************************
Librarys
- WiFi.h V0.16.1
**************************************************************************************************
OLED Schriftarten:
https://arduino-projekte.info/schriftarten-fuer-oled-display/#torussansbold8_8r

 **************************************************************************************************/

#include                              <time.h>                              // for time calculations
#include                              <WiFi.h>                              // for wifi
#include                              <WiFiUdp.h>                           // for udp via wifi
#include                              <U8g2lib.h>                           // see https://github.com/olikraus/u8g2/wiki/u8g2reference
//#include "SH1106.h"
#include <U8g2lib.h>
#include <Wire.h>

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Constants
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

#define   FONT_ONE_HEIGHT               8                                   // font one height in pixels
#define   FONT_TWO_HEIGHT               20                                  // font two height in pixels
#define   NTP_DELAY_COUNT               20                                  // delay count for ntp update
#define   NTP_PACKET_LENGTH             48                                  // ntp packet length
#define   TIME_ZONE                     (+2)                                // offset from utc BERLIN
#define   UDP_PORT                      4000                                // UDP listen port

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Variables
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

char      chBuffer[128];                                                    // general purpose character buffer

char      chSSID[] =                      "xxx";                   // your network SSID
char      chPassword[] =                  "xxx";               // your network password


bool      bTimeReceived =                 false;                            // time has not been received
//U8G2_SSD1306_128X64_NONAME_F_HW_I2C       u8g2(U8G2_R0, 16, 15, 4);         // OLED graphics
//SH1106  display(0x3C, 21,22);   //1,3"
U8G2_SH1106_128X64_NONAME_F_HW_I2C u8g2(U8G2_R0, /* reset=*/ U8X8_PIN_NONE);
int       nWifiStatus =                   WL_IDLE_STATUS;                   // wifi status
WiFiUDP   Udp;

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Setup
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void setup()
{
  // Serial.

  Serial.begin(115200);
  while(!Serial)
  {
    Serial.print('.');
  }

  // OLED graphics.

  u8g2.begin();
  u8g2.setFont(u8g2_font_6x10_tr);
  u8g2.setFontRefHeightExtendedText();
  u8g2.setDrawColor(1);
  u8g2.setFontPosTop();
  u8g2.setFontDirection(0);

  // Wifi.

    // Display title.

    u8g2.clearBuffer();
    sprintf(chBuffer, "%s", "Connecting to:");
    u8g2.drawStr(64 - (u8g2.getStrWidth(chBuffer) / 2), 0, chBuffer);
    sprintf(chBuffer, "%s", chSSID);
    u8g2.drawStr(64 - (u8g2.getStrWidth(chBuffer) / 2), 31 - (FONT_ONE_HEIGHT / 2), chBuffer);
    u8g2.sendBuffer();

    // Connect to wifi.

    Serial.print("NTP clock: connecting to wifi");
    WiFi.begin(chSSID, chPassword);
    while(WiFi.status() != WL_CONNECTED)
    {
        Serial.print(".");
        delay(500);
    }

    Serial.println();
    sprintf(chBuffer, "NTP clock: WiFi connected to %s.", chSSID);
    Serial.println(chBuffer);

    // Display connection stats.

      // Clean the display buffer.

      u8g2.clearBuffer();

      // Display the title.

      sprintf(chBuffer, "%s", "WiFi Stats:");
      u8g2.drawStr(64 - (u8g2.getStrWidth(chBuffer) / 2), 0, chBuffer);

      // Display the ip address assigned by the wifi router.

      char  chIp[81];
      WiFi.localIP().toString().toCharArray(chIp, sizeof(chIp) - 1);
      sprintf(chBuffer, "IP  : %s", chIp);
      u8g2.drawStr(0, FONT_ONE_HEIGHT * 2, chBuffer);

      // Display the ssid of the wifi router.

      sprintf(chBuffer, "SSID: %s", chSSID);
      u8g2.drawStr(0, FONT_ONE_HEIGHT * 3, chBuffer);

      // Display the rssi.

      sprintf(chBuffer, "RSSI: %d", WiFi.RSSI());
      u8g2.drawStr(0, FONT_ONE_HEIGHT * 4, chBuffer);

      // Display waiting for ntp message.

      u8g2.drawStr(0, FONT_ONE_HEIGHT * 6, "Awaiting NTP time...");

      // Now send the display buffer to the OLED.

      u8g2.sendBuffer();

  // Udp.

  Udp.begin(UDP_PORT);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////
//
// Main loop
//
//////////////////////////////////////////////////////////////////////////////////////////////////////////////

void  loop()
{
  // Local variables.

  static  int   nNtpDelay = NTP_DELAY_COUNT;
  static  byte  chNtpPacket[NTP_PACKET_LENGTH];

  // Check for time to send ntp request.

  if(bTimeReceived == false)
  {
     // Have yet to receive time from the ntp server, update delay counter.

      nNtpDelay += 1;

      // Check for time to send ntp request.

      if(nNtpDelay >= NTP_DELAY_COUNT)
      {
          // Time to send ntp request, reset delay.

          nNtpDelay = 0;

          // Send ntp time request.

            // Initialize ntp packet.

                // Zero out chNtpPacket.

                memset(chNtpPacket, 0, NTP_PACKET_LENGTH);

                // Set the ll (leap indicator), vvv (version number) and mmm (mode) bits.
                //
                //  These bits are contained in the first byte of chNtpPacker and are in
                // the following format:  llvvvmmm
                //
                // where:
                //
                //    ll  (leap indicator) = 0
                //    vvv (version number) = 3
                //    mmm (mode)           = 3

                chNtpPacket[0]  = 0b00011011;

            // Send the ntp packet.

            IPAddress ipNtpServer(129, 6, 15, 28); //const char* ntpServer = "de.pool.ntp.org";

            Udp.beginPacket(ipNtpServer, 123);
            Udp.write(chNtpPacket, NTP_PACKET_LENGTH);
            Udp.endPacket();

            Serial.println("NTP clock: ntp packet sent to ntp server.");
            Serial.print("NTP clock: awaiting response from ntp server");
      }

      Serial.print(".");

      // Check for time to check for server response.

      if(nNtpDelay == (NTP_DELAY_COUNT - 1))
      {
          // Time to check for a server response.

          if(Udp.parsePacket())
          {
              // Server responded, read the packet.

              Udp.read(chNtpPacket, NTP_PACKET_LENGTH);

              // Obtain the time from the packet, convert to Unix time, and adjust for the time zone.

              struct  timeval tvTimeValue = {0, 0};

              tvTimeValue.tv_sec = ((unsigned long)chNtpPacket[40] << 24) +       // bits 24 through 31 of ntp time
                                   ((unsigned long)chNtpPacket[41] << 16) +       // bits 16 through 23 of ntp time
                                   ((unsigned long)chNtpPacket[42] <<  8) +       // bits  8 through 15 of ntp time
                                   ((unsigned long)chNtpPacket[43]) -             // bits  0 through  7 of ntp time
                                   (((70UL * 365UL) + 17UL) * 86400UL) +          // ntp to unix conversion
                                   (TIME_ZONE * 3600UL) +                         // time zone adjustment
                                   (5);                                           // transport delay fudge factor

              // Set the ESP32 rtc.

              settimeofday(& tvTimeValue, NULL);

              // Time has been received.

              bTimeReceived = true;

              // Output date and time to serial.

              struct tm * tmPointer = localtime(& tvTimeValue.tv_sec);
              strftime (chBuffer, sizeof(chBuffer), "%a, %d %b %Y %H:%M:%S",  tmPointer);
              Serial.println();
              Serial.print("NTP clock: response received, time written to ESP32 rtc: ");
              Serial.println(chBuffer);

              // No longer need wifi.

              WiFi.mode(WIFI_OFF);
          }
          else
          {
              // Server did not respond.

              Serial.println("NTP clock: packet not received.");
          }
      }
  }

  // Update OLED.

  if(bTimeReceived)
  {
      // Ntp time has been received, ajusted and written to the ESP32 rtc, so obtain the time from the ESP32 rtc.

      struct  timeval tvTimeValue;
      gettimeofday(& tvTimeValue, NULL);

      // Erase the display buffer.

      u8g2.clearBuffer();

      // Obtain a pointer to local time.

      struct tm * tmPointer = localtime(& tvTimeValue.tv_sec);

      // Display the date.

      strftime(chBuffer, sizeof(chBuffer), "%a, %d %b %Y",  tmPointer);
      u8g2.setFont(u8g2_font_6x10_tr);
      u8g2.drawStr(64 - (u8g2.getStrWidth(chBuffer) / 2), 0, chBuffer);

      // Display the time.

      strftime(chBuffer, sizeof(chBuffer), "%I:%M:%S",  tmPointer);
      u8g2.setFont(u8g2_font_fur20_tn);
      u8g2.drawStr(10, 45 - FONT_TWO_HEIGHT, chBuffer);

      // Send the display buffer to the OLED

      u8g2.sendBuffer();
  }

  // Give up some time.

  delay(200);
}

RAW code

nach oben